Cosa fa $ .when.apply ($, someArray)?

Sto leggendo di rinvii e promesse e continuo a incontrarmi $.when.apply($, someArray). Non sono un po 'chiaro su cosa fa esattamente, cercando una spiegazione che una riga funzioni esattamente (non l'intero frammento di codice). Ecco un po 'di contesto:

var data = [1,2,3,4]; // the ids coming back from serviceA
var processItemsDeferred = [];

for(var i = 0; i < data.length; i++){
  processItemsDeferred.push(processItem(data[i]));
}

$.when.apply($, processItemsDeferred).then(everythingDone); 

function processItem(data) {
  var dfd = $.Deferred();
  console.log('called processItem');

  //in the real world, this would probably make an AJAX call.
  setTimeout(function() { dfd.resolve() }, 2000);    

  return dfd.promise();
}

function everythingDone(){
  console.log('processed all items');
}

.applyviene utilizzato per chiamare una funzione con un array di argomenti. Prende ogni elemento dell'array e lo utilizza come parametro per la funzione. .applypuò anche cambiare il context ( this) all'interno di una funzione.

Quindi, prendiamo $.when. Si usa dire "quando tutte queste promesse sono state risolte ... fai qualcosa". Richiede un numero infinito (variabile) di parametri.

Nel tuo caso, hai una serie di promesse; non sai a quanti parametri stai passando $.when. Passare l'array stesso a $.whennon funzionerebbe, perché si aspetta che i suoi parametri siano promesse, non un array.

È qui che .applyentra in gioco. Prende l'array e chiama $.whenogni elemento come parametro (e si assicura che thissia impostato su jQuery/ $), quindi funziona tutto :-)

$ .when accetta un numero qualsiasi di parametri e si risolve quando tutti questi sono stati risolti.

anyFunction .apply (thisValue, arrayParameters) chiama la funzione anyFunction impostandone il contesto (thisValue sarà il this all'interno di quella chiamata di funzione) e passa tutti gli oggetti in arrayParameters come parametri individuali.

Per esempio:

$.when.apply($, [def1, def2])

Equivale a:

$.when(def1, def2)

Ma la applicano modo di chiamata consente di passare una matrice di numero imprecisato di parametri. (Nel codice, stai dicendo che i tuoi dati provengono da un servizio, quindi questo è l'unico modo per chiamare $ .quando )

Qui, il codice è completamente documentato.

// 1. Declare an array of 4 elements
var data = [1,2,3,4]; // the ids coming back from serviceA
// 2. Declare an array of Deferred objects
var processItemsDeferred = [];

// 3. For each element of data, create a Deferred push push it to the array
for(var i = 0; i < data.length; i++){
  processItemsDeferred.push(processItem(data[i]));
}

// 4. WHEN ALL Deferred objects in the array are resolved THEN call the function
//    Note : same as $.when(processItemsDeferred[0], processItemsDeferred[1], ...).then(everythingDone);
$.when.apply($, processItemsDeferred).then(everythingDone); 

// 3.1. Function called by the loop to create a Deferred object (data is numeric)
function processItem(data) {
  // 3.1.1. Create the Deferred object and output some debug
  var dfd = $.Deferred();
  console.log('called processItem');

  // 3.1.2. After some timeout, resolve the current Deferred
  //in the real world, this would probably make an AJAX call.
  setTimeout(function() { dfd.resolve() }, 2000);    

  // 3.1.3. Return that Deferred (to be inserted into the array)
  return dfd.promise();
}

// 4.1. Function called when all deferred are resolved
function everythingDone(){
  // 4.1.1. Do some debug trace
  console.log('processed all items');
}

Purtroppo non posso essere d'accordo con voi ragazzi.

$.when.apply($, processItemsDeferred).always(everythingDone);

Chiamerà everythingDonenon appena un differito viene rifiutato , anche se ci sono altri differiti in sospeso .

Ecco lo script completo (consiglio http://jsfiddle.net/ ):

var data = [1,2,3,4]; // the ids coming back from serviceA
var processItemsDeferred = [];

for(var i = 0; i < data.length; i++){
  processItemsDeferred.push(processItem(data[i]));
}

processItemsDeferred.push($.Deferred().reject());
//processItemsDeferred.push($.Deferred().resolve());

$.when.apply($, processItemsDeferred).always(everythingDone); 

function processItem(data) {
  var dfd = $.Deferred();
  console.log('called processItem');

  //in the real world, this would probably make an AJAX call.
  setTimeout(function() { dfd.resolve(); }, 2000);    

  return dfd.promise();
}

function everythingDone(){
  alert('processed all items');
}

È un bug? Vorrei usarlo come il signore sopra descritto.

Forse qualcuno può trovarlo utile:

$.when.apply($, processItemsDeferred).then(everythingDone).fail(noGood);

EverythingDone non viene chiamato in caso di rifiuto

$ .when da solo consente di richiamare una richiamata quando tutte le promesse ad esso passate vengono risolte / rifiutate. Normalmente, $. Quando accetta un numero variabile di argomenti, l'uso di .apply rende possibile passargli un array di argomenti, è molto potente. Per maggiori informazioni su .apply: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Function/apply

Grazie per la tua elegante soluzione:

var promise;

for(var i = 0; i < data.length; i++){
  promise = $.when(promise, processItem(data[i]));
}

promise.then(everythingDone);

Solo un punto: quando si utilizza resolveWithper ottenere alcuni parametri, si interrompe a causa della promessa iniziale impostata su undefined. Cosa ho fatto per farlo funzionare:

// Start with an empty resolved promise - undefined does the same thing!
var promise;

for(var i = 0; i < data.length; i++){
  if(i==0) promise = processItem(data[i]);
  else promise = $.when(promise, processItem(data[i]));
}

promise.then(everythingDone);