Comment puis-je attendre un ensemble de fonctions de rappel asynchrones?

J'ai du code qui ressemble à ceci en javascript:

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

Une fois TOUS ces appels asynchrones terminés, je veux calculer le min sur tous les tableaux.

Comment puis-je les attendre tous?

Ma seule idée pour le moment est d'avoir un tableau de booléens appelé done, et de définir done [i] sur true dans la ième fonction de rappel, puis de dire while (tout n'est pas fait) {}

edit: Je suppose qu'une solution possible, mais laide, serait d'éditer le tableau done dans chaque rappel, puis d'appeler une méthode si toutes les autres sont définies à partir de chaque rappel, ainsi le dernier rappel à terminer appellera la méthode continue.

Merci d'avance.

Vous n'avez pas été très précis avec votre code, alors je vais inventer un scénario. Supposons que vous ayez 10 appels ajax et que vous vouliez accumuler les résultats de ces 10 appels ajax, puis quand ils ont tous terminé, vous voulez faire quelque chose. Vous pouvez le faire comme ceci en accumulant les données dans un tableau et en gardant une trace de la fin du dernier:

Compteur manuel

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

Remarque: la gestion des erreurs est importante ici (non affichée car elle est spécifique à la façon dont vous effectuez vos appels ajax). Vous voudrez peut-être réfléchir à la manière dont vous allez gérer le cas où un appel ajax ne se termine jamais, soit avec une erreur, soit bloqué pendant une longue période ou expire après un long moment.

Promesses jQuery

Ajout à ma réponse en 2014. Ces jours-ci, les promesses sont souvent utilisées pour résoudre ce type de problème puisque jQuery's $.ajax()retourne déjà une promesse et vous $.when()fera savoir quand un groupe de promesses sont toutes résolues et collectera les résultats de retour pour vous:

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

Promesses standard ES6

Comme spécifié dans la réponse de kba : si vous avez un environnement avec des promesses natives intégrées (navigateur moderne ou node.js ou utilisant babeljs transpile ou utilisant un promesse polyfill), vous pouvez utiliser les promesses spécifiées par ES6. Consultez ce tableau pour la prise en charge du navigateur. Les promesses sont prises en charge dans à peu près tous les navigateurs actuels, à l'exception d'IE.

Si doAjax()retourne une promesse, vous pouvez le faire:

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 vous avez besoin de transformer une opération asynchrone sans promesse en une opération qui renvoie une promesse, vous pouvez la «promettre» comme ceci:

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

Et, puis utilisez le modèle ci-dessus:

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

Promesses Bluebird

Si vous utilisez une bibliothèque plus riche en fonctionnalités, telle que la bibliothèque de promesses Bluebird , elle possède des fonctions supplémentaires intégrées pour vous faciliter la tâche:

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

Arrivée à partir de 2015: nous avons maintenant des promesses natives dans le navigateur le plus récent (Edge 12, Firefox 40, Chrome 43, Safari 8, Opera 32 et navigateur Android 4.4.4 et iOS Safari 8.4, mais pas Internet Explorer, Opera Mini et les versions antérieures d'Android).

Si nous voulons effectuer 10 actions asynchrones et être notifié lorsqu'elles sont toutes terminées, nous pouvons utiliser le natif Promise.all, sans aucune bibliothèque externe:

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

Vous pouvez utiliser l' objet Deferred de jQuery avec la méthode 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
});

Vous pouvez l'émuler comme ceci:

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

puis chaque appel asynchrone fait ceci:

countDownLatch.count++;

tandis que dans chaque rappel asynchrone à la fin de la méthode, vous ajoutez cette ligne:

countDownLatch.check();

En d'autres termes, vous émulez une fonctionnalité de comptage à rebours.

C'est la manière la plus soignée à mon avis.

Promise.all

FetchAPI

(pour une raison quelconque, Array.map ne fonctionne pas dans les fonctions .then pour moi. Mais vous pouvez utiliser un .forEach et [] .concat () ou quelque chose de similaire)

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

Utilisez une bibliothèque de flux de contrôle comme 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)
})