Qual è la differenza tra le azioni di classe e le azioni di istanza in AngularJs?

Question

From the docs:

azioni Class restituiscono un'istanza vuota (con proprietà aggiuntive sotto). Le azioni di istanza restituiscono la promessa dell'azione

Le documentazioni tuttavia non distinguono chiaramente tra azioni di classe e azioni di istanza. Potresti per favore indicare le differenze con un buon esempio, se possibile?

Answer 1

Quando si crea un nuovo tipo di risorsa, viene fornito un elenco di azioni che è possibile eseguire. Per impostazione predefinita, questi sono get, save, query, delete e remove (penso che rimuovere sia solo un alias di eliminazione). Puoi aggiungere il tuo, come si dice nei documenti.

Il problema dell'istanza di classe vs riguarda qualcosa che fa per comodità d'uso. "Azioni di classe" si riferisce a chiamare l'azione fuori dalla classe di risorse che tu stesso crei, un po 'come metodi statici o condivisi in alcuni altri linguaggi. Questo è utile come punto di ingresso per ottenere, interrogare o salvare un'istanza della risorsa quando non si dispone già dell'istanza. get e query sono l'esempio più chiaro di questo. Se hai una risorsa Car e devi recuperarla, da dove inizi? Con un'azione di classe, ovviamente, come get.

Ora, quando la classe di risorse recupera un'istanza esistente, o si crea una nuova istanza, $resource si estenderà l'istanza con le azioni definite per la risorsa, ma li precedere con un $ in modo che non collidono con campi la tua risorsa. Queste sono le tue azioni di istanza. La differenza tra istanza e classe è che l'istanza viene eseguita nel contesto dell'istanza corrente. Pertanto, se si è un'istanza get, ma si chiama $save o $delete in quell'istanza, verrà salvata o eliminata in modo specifico. Le azioni di istanza ci sono semplicemente per comodità.

Quindi sono praticamente la stessa cosa, la differenza è il contesto in cui vengono utilizzati.

function($resource) {  

    // first let's define a new resource for car, where all cars have an id field 
    // calling $resource will create a new resource class that can be used to 
    // create, retrieve, update, or delete instances 
    // this is usually done as a service and injected into controllers as needed. 
    var Car = $resource('/api/car/:id', {id: '@id'}); 

    // the car class we just created has some class actions that can help you query for or get car instances 
    // let's create a new instance of a car and save it 
    var newCar = new Car({make: 'Toyota', model: 'Prius'}); 
    // the prototype of Car includes the instance action versions of the actions defined for the resource. below, $save is your instance action 
    newCar.$save(); // server will respond with the object after it's saved, so we can now access the id. let's say the id it returned is 24, we'll reference this value later. 


    // now, let's imagine some time later we want to retrieve the car and update it 
    // Car.get is a class action that requests the resource from the server, parses the JSON into an object, and merges it with the Car instance prototype so you have your instance actions 
    // let's get the car we created previously. 
    // remember, this is done asynchronously, so we will do our work in a success handler that we provide to get 
    Car.get({id: 24}, function(myCar) { 
     // let's update the car now that we have it. let's set the year of the model and the color 
     myCar.year = 2004; 
     myCar.color = 'white'; 

     // now, let's save our changes by calling the instance action $save 
     myCar.$save(); 
    }); 


    // now, let's query for all cars and get an array back 
    // query is a class function that expects an array of your resource to be returned 
    Car.query(function(cars) { 
     // trivial example, we're just going to enumerate the cars we found and log some info about them 
     for(var i = 0; i < cars.length; i++) 
      console.log('Found ' + cars[0].color + ' ' cars[0].year + ' ' + cars[0].make + ' ' + cars[0].model); 
    }); 


    // ok, let's delete the car we created earlier. use the class action delete 
    Car.delete({id: 24}); 
} 

È possibile tecnicamente chiamare qualsiasi azione sia come classe o come un esempio, ma sarà ovvio che alcuni sono scomodi da utilizzare come azioni istanza e viceversa. Ad esempio, mentre tecnicamente puoi usare query come azione di istanza, in pratica non lo faresti perché è un lavoro extra ed è imbarazzante (dovresti fare new Car().$query(). Questo è sciocco: Car.query() è più semplice e ha più senso). Quindi, l'utilizzo nel mio esempio sopra rappresenta il tuo normale utilizzo.

---

Aggiornamento:

save vs $save

$save è simile a save, ma assume i dati che si desidera inviare durante il salvataggio è di per sé, in quanto $save è un'azione di istanza. È particolarmente utile perché, una volta ricevuta la risposta, si aggiornerà con l'oggetto restituito dall'endpoint HTTP.Pertanto, se il servizio salva l'oggetto con alcuni valori aggiuntivi compilati sul lato server, ad esempio un ID, quindi invia l'oggetto indietro come JSON, $save aggiornerà l'istanza con l'oggetto JSON restituito.

var car = new Car({make: 'Toyota', model: 'Prius'}); 
// at this point there is no id property, only make and model 
car.$save(function() { 
    // angular is async, so we need a success handler to continue the explanation 

    // assuming your server assigned an ID and sent the resulting object back as JSON, you can now access id off the original object 
    console.log(car.id); // has a value now 
}); 

Si potrebbe fare qualcosa di simile con il metodo della classe, ma è imbarazzante, soprattutto se altro codice nel controller deve fare riferimento l'auto come si sta lavorando su di esso

Car.save({make: 'Toyota', model: 'Prius'}, function(car) { 
     // ok, we have an ID now 
     console.log(car.id); 
}); 

o

var car = new Car({...}); 
Car.save(car, function(newCar) { 
     car = newCar; // wut? that's awkward 
}); 

savepotrebbe essere essere utile durante le istanze in cui si sta salvando rapidamente un piccolo oggetto, o sono perfo rompere una sorta di "fuoco e dimenticare". Ad ogni modo, uso raramente lo save.