Node.js: la Meilleure façon d'effectuer de multiples opérations asynchrones, puis faire quelque chose d'autre?

Pas de hacks nécessaire

Je vous conseille d'utiliser le asynchrone module, il rend ces sortes de choses beaucoup plus facile.

async fournit async.eachSeries comme un async remplacement pour arr.forEach et vous permet de passer un done fonction de rappel quand il est complet. Il permettra de traiter chacun de ces éléments dans une série, tout comme forEach. Aussi, il sera idéalement bulle erreurs de rappel, de sorte que vous n'avez pas besoin de gestionnaire de la logique à l'intérieur de la boucle. Si vous voulez/besoin parallèle de traitement, vous pouvez utiliser async.chaque.

Il y aura aucun blocage entre les async.eachSeries appel et le rappel.

async.eachSeries(feedsToFetch, function(feedUri, done) {

  //call your async function
  feed(feedUri, function(err, feedArticles) {

    //if there's an error, "bubble" it to the callback
    if (err) return done(err);

    //your operation here;
    articles = articles.concat(feedArticles);

    //this task is done
    done();
  });
}, function(err) {

  //errors generated in the loop above will be accessible here
  if (err) throw err;

  //we're all done!
  console.log("all done!");
});

Sinon, vous pourriez construire un tableau des opérations asynchrones et de les transmettre à async.série. La série traitera vos résultats dans un série (non parallèles) et d'appeler la fonction de rappel lorsque chaque fonction est terminée. La seule raison d'utiliser ce fil async.eachSeries serait si vous avez préféré le familier arr.forEach syntaxe.

//create an array of async tasks
var tasks = [];

feedsToFetch.forEach(function (feedUri) {

  //add each task to the task array
  tasks.push(function() {

    //your operations
    feed(feedUri, function(err, feedArticles) {
      if (err) throw err;
      articles = articles.concat(feedArticles);
    });
  });
});

//call async.series with the task array and callback
async.series(tasks, function() {
 console.log("done !");
});

---

Ou vous pouvez Rouler Vos Propres™

Peut-être, vous vous sentez supplémentaire ambitieux ou peut-être vous ne voulez pas compter sur la async de dépendance. Peut-être vous êtes juste ennuyé comme je l'étais. De toute façon, j'ai volontairement copié l'API de async.eachSeries pour le rendre facile à comprendre comment cela fonctionne.

Une fois que nous supprimer les commentaires ici, nous avons juste 9 lignes de code qui peuvent être réutilisés pour tout tableau que l'on veut traiter de manière asynchrone! Il ne sera pas modifier le tableau d'origine, des erreurs peuvent être envoyées à "court-circuit" de l'itération, et séparé de rappel peuvent être utilisés. Il permettra également de travailler sur des tableaux vides. Un peu de fonctionnalité pour seulement 9 lignes 🙂

//void asyncForEach(Array arr, Function iterator, Function callback)
//  * iterator(item, done) - done can be called with an err to shortcut to callback
//  * callback(done)       - done recieves error if an iterator sent one
function asyncForEach(arr, iterator, callback) {

  //create a cloned queue of arr
  var queue = arr.slice(0);

  //create a recursive iterator
  function next(err) {

    //if there's an error, bubble to callback
    if (err) return callback(err);

    //if the queue is empty, call the callback with no error
    if (queue.length === 0) return callback(null);

    //call the callback with our task
    //we pass `next` here so the task can let us know when to move on to the next task
    iterator(queue.shift(), next);
  }

  //start the loop;
  next();
}

Maintenant, nous allons créer un exemple de fonction async à utiliser avec elle. Nous allons faux le retard avec un setTimeout de 500 ms ici.

//void sampleAsync(String uri, Function done)
//  * done receives message string after 500 ms
function sampleAsync(uri, done) {

  //fake delay of 500 ms
  setTimeout(function() {

    //our operation
    //<= "foo"
    //=> "async foo !"
    var message = ["async", uri, "!"].join(" ");

    //call done with our result
    done(message);
  }, 500);
}

Ok, nous allons voir comment ils travaillent !

tasks = ["cat", "hat", "wat"];

asyncForEach(tasks, function(uri, done) {
  sampleAsync(uri, function(message) {
    console.log(message);
    done();
  });
}, function() {
  console.log("done");
});

De sortie (500 ms de retard avant chaque sortie)

async cat !
async hat !
async wat !
done

OriginalL'auteur user633183