Como posso esperar pelo conjunto de funções de retorno de chamada assíncronas?

Tenho um código parecido com este em javascript:

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

Depois que TODAS essas chamadas assíncronas forem feitas, quero calcular o mínimo de todas as matrizes.

Como posso esperar por todos eles?

Minha única ideia agora é ter um array de booleanos chamado done e definir done [i] como true na i-ésima função de retorno de chamada e dizer while (nem todos estão concluídos) {}

editar: Suponho que uma solução possível, mas feia, seria editar o array done em cada retorno de chamada e, em seguida, chamar um método se todos os outros feitos forem definidos em cada retorno de chamada, portanto, o último retorno de chamada a ser concluído chamará o método contínuo.

Desde já, obrigado.

Você não foi muito específico com seu código, então vou inventar um cenário. Digamos que você tenha 10 chamadas ajax e deseja acumular os resultados dessas 10 chamadas ajax e, quando todas elas forem concluídas, você deseja fazer algo. Você pode fazer isso assim, acumulando os dados em uma matriz e acompanhando quando o último foi concluído:

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: o tratamento de erros é importante aqui (não mostrado porque é específico para como você está fazendo suas chamadas ajax). Você vai querer pensar sobre como vai lidar com o caso em que uma chamada de ajax nunca é concluída, seja com um erro ou travada por um longo tempo ou expira após um longo tempo.

jQuery Promises

Somando-se a minha resposta em 2014. Hoje em dia, as promessas costumam ser usadas para resolver esse tipo de problema, já que a jQuery's $.ajax()já retorna uma promessa e $.when()avisará quando um grupo de promessas for resolvido e coletará os resultados de retorno para você:

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
});

ES6 Standard Promises

Conforme especificado na resposta de kba : se você tem um ambiente com promessas nativas integradas (navegador moderno ou node.js ou usando transpile babeljs ou usando um polyfill de promessa), então você pode usar promessas especificadas no ES6. Consulte esta tabela para suporte ao navegador. As promessas são suportadas em praticamente todos os navegadores atuais, exceto o IE.

Se doAjax()retornar uma promessa, você pode fazer o seguinte:

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
});

Se você precisar transformar uma operação assíncrona sem promessa em uma que retorne uma promessa, poderá "prometê-la" assim:

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

E, em seguida, use o padrão acima:

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
});

Bluebird Promises

Se você usar uma biblioteca com mais recursos, como a biblioteca de promessa do Bluebird , ela terá algumas funções adicionais integradas para tornar isso mais fácil:

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

Verificando a partir de 2015: agora temos promessas nativas no navegador mais recente (Edge 12, Firefox 40, Chrome 43, Safari 8, Opera 32 e navegador Android 4.4.4 e iOS Safari 8.4, mas não Internet Explorer, Opera Mini e versões anteriores do Android).

Se quisermos realizar 10 ações assíncronas e ser notificados quando todas terminarem, podemos usar o nativo Promise.all, sem nenhuma biblioteca externa:

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);
});

Você pode usar o objeto Deferred do jQuery junto com o 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
});

Você pode emular assim:

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

então, cada chamada assíncrona faz isso:

countDownLatch.count++;

enquanto em cada chamada assíncrona no final do método, você adiciona esta linha:

countDownLatch.check();

Em outras palavras, você emula uma funcionalidade de trava de contagem regressiva.

Essa é a maneira mais bacana na minha opinião.

Promise.all

FetchAPI

(por algum motivo, Array.map não funciona dentro das funções .então para mim. Mas você pode usar um .forEach e [] .concat () ou algo semelhante)

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);
})

Use uma biblioteca de fluxo de controle 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)
})