¿Cómo puedo esperar el conjunto de funciones de devolución de llamada asincrónicas?

Tengo un código que se parece a esto en javascript:

forloop {
    //async call, returns an array to its callback
}

Una vez realizadas TODAS esas llamadas asíncronas, quiero calcular el mínimo de todas las matrices.

¿Cómo puedo esperar a todos?

Mi única idea en este momento es tener una matriz de valores booleanos llamados done, y establecer done [i] en verdadero en la función de devolución de llamada i-ésima, luego decir while (no todos están listos) {}

editar: Supongo que una solución posible, pero fea, sería editar la matriz done en cada devolución de llamada, luego llamar a un método si todos los demás hechos se establecen desde cada devolución de llamada, por lo que la última devolución de llamada para completar llamará al método continuo.

Gracias por adelantado.

No has sido muy específico con tu código, así que inventaré un escenario. Digamos que tiene 10 llamadas ajax y desea acumular los resultados de esas 10 llamadas ajax y luego, cuando todas se hayan completado, desea hacer algo. Puede hacerlo así acumulando los datos en una matriz y haciendo un seguimiento de cuándo ha terminado el último:

Contador manual

var ajaxCallsRemaining = 10;
var returnedData = [];

for (var i = 0; i < 10; i++) {
    doAjax(whatever, function(response) {
        // success handler from the ajax call

        // save response
        returnedData.push(response);

        // see if we're done with the last ajax call
        --ajaxCallsRemaining;
        if (ajaxCallsRemaining <= 0) {
            // all data is here now
            // look through the returnedData and do whatever processing 
            // you want on it right here
        }
    });
}

Nota: el manejo de errores es importante aquí (no se muestra porque es específico de cómo está haciendo sus llamadas ajax). Querrá pensar en cómo manejará el caso cuando una llamada ajax nunca se complete, ya sea con un error o se atasque durante mucho tiempo o se agote después de mucho tiempo.

Promesas de jQuery

Agregando a mi respuesta en 2014. En estos días, las promesas se usan a menudo para resolver este tipo de problema, ya que jQuery $.ajax()ya devuelve una promesa y $.when()le informará cuando un grupo de promesas se resuelvan y recopilará los resultados devueltos por usted:

var promises = [];
for (var i = 0; i < 10; i++) {
    promises.push($.ajax(...));
}
$.when.apply($, promises).then(function() {
    // returned data is in arguments[0][0], arguments[1][0], ... arguments[9][0]
    // you can process it here
}, function() {
    // error occurred
});

Promesas estándar de ES6

Como se especifica en la respuesta de kba : si tiene un entorno con promesas nativas integradas (navegador moderno o node.js o usando babeljs transpile o usando un polyfill de promesa), entonces puede usar promesas especificadas por ES6. Consulte esta tabla para conocer la compatibilidad con el navegador. Las promesas son compatibles con casi todos los navegadores actuales, excepto IE.

Si doAjax()devuelve una promesa, puede hacer esto:

var promises = [];
for (var i = 0; i < 10; i++) {
    promises.push(doAjax(...));
}
Promise.all(promises).then(function() {
    // returned data is in arguments[0], arguments[1], ... arguments[n]
    // you can process it here
}, function(err) {
    // error occurred
});

Si necesita convertir una operación asíncrona sin promesa en una que devuelva una promesa, puede "promisificarla" de esta manera:

function doAjax(...) {
    return new Promise(function(resolve, reject) {
        someAsyncOperation(..., function(err, result) {
            if (err) return reject(err);
            resolve(result);
        });
    });
}

Y luego usa el patrón anterior:

var promises = [];
for (var i = 0; i < 10; i++) {
    promises.push(doAjax(...));
}
Promise.all(promises).then(function() {
    // returned data is in arguments[0], arguments[1], ... arguments[n]
    // you can process it here
}, function(err) {
    // error occurred
});

Promesas de Bluebird

Si usa una biblioteca con más funciones, como la biblioteca de promesas Bluebird , entonces tiene algunas funciones adicionales integradas para facilitar esto:

 var doAjax = Promise.promisify(someAsync);
 var someData = [...]
 Promise.map(someData, doAjax).then(function(results) {
     // all ajax results here
 }, function(err) {
     // some error here
 });

Registro desde 2015: ahora tenemos promesas nativas en el navegador más reciente (Edge 12, Firefox 40, Chrome 43, Safari 8, Opera 32 y el navegador Android 4.4.4 y iOS Safari 8.4, pero no Internet Explorer, Opera Mini y versiones anteriores de Android).

Si queremos realizar 10 acciones asíncronas y recibir una notificación cuando todas hayan terminado, podemos usar la nativa Promise.all, sin bibliotecas externas:

function asyncAction(i) {
    return new Promise(function(resolve, reject) {
        var result = calculateResult();
        if (result.hasError()) {
            return reject(result.error);
        }
        return resolve(result);
    });
}

var promises = [];
for (var i=0; i < 10; i++) {
    promises.push(asyncAction(i));
}

Promise.all(promises).then(function AcceptHandler(results) {
    handleResults(results),
}, function ErrorHandler(error) {
    handleError(error);
});

Puede usar el objeto Deferred de jQuery junto con el método when .

deferredArray = [];
forloop {
    deferred = new $.Deferred();
    ajaxCall(function() {
      deferred.resolve();
    }
    deferredArray.push(deferred);
}

$.when(deferredArray, function() {
  //this code is called after all the ajax calls are done
});

Puedes emularlo así:

  countDownLatch = {
     count: 0,
     check: function() {
         this.count--;
         if (this.count == 0) this.calculate();
     },
     calculate: function() {...}
  };

luego cada llamada asíncrona hace esto:

countDownLatch.count++;

mientras que en cada llamada asynch al final del método, agrega esta línea:

countDownLatch.check();

En otras palabras, emula una funcionalidad de pestillo de cuenta regresiva.

Esta es la forma más ordenada en mi opinión.

Promise.all

FetchAPI

(por alguna razón, Array.map no funciona dentro de .then funciona para mí. Pero puedes usar un .forEach y [] .concat () o algo similar)

Promise.all([
  fetch('/user/4'),
  fetch('/user/5'),
  fetch('/user/6'),
  fetch('/user/7'),
  fetch('/user/8')
]).then(responses => {
  return responses.map(response => {response.json()})
}).then((values) => {
  console.log(values);
})

Utilice una biblioteca de flujo de control como after

after.map(array, function (value, done) {
    // do something async
    setTimeout(function () {
        // do something with the value
        done(null, value * 2)
    }, 10)
}, function (err, mappedArray) {
    // all done, continue here
    console.log(mappedArray)
})