Node.js: Beste Weg, um mehrere asynchrone Operationen, dann etwas anderes tun?

Keine hacks notwendig

Ich würde empfehlen, mit der async - Modul, wie es macht diese Dinge viel einfacher.

async bietet async.eachSeries als asynchrone Ersatz für arr.forEach und ermöglicht die übergabe eines done callback-Funktion, wenn es fertig ist. Es wird die Verarbeitung der einzelnen Elemente in einer Reihe, so wie forEach tut. Es ist auch bequem bubble Fehler auf Ihren Rückruf, so dass Sie nicht haben, um handler-Logik innerhalb der Schleife. Wenn Sie möchten/benötigen parallel Verarbeitung, die Sie verwenden können,async.jeder.

Wird es keine Blockierung zwischen den async.eachSeries Anruf und dem Rückruf.

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

Alternativ können Sie erstellen eine Reihe von asynchronen Operationen, und übergeben Sie an async.Serie. Serie verarbeiten Ihre Ergebnisse in einem Serie (nicht parallel) und rufe den callback, wenn jede Funktion abgeschlossen ist. Der einzige Grund, dies nicht über async.eachSeries wäre, wenn Sie bevorzugt das vertraute arr.forEach syntax.

//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 !");
});

Oder Sie können Roll your Own™

Vielleicht haben Sie das Gefühl zusätzliche ehrgeizig oder vielleicht haben Sie nicht wollen, verlassen Sie sich auf die async Abhängigkeit. Vielleicht sind Sie nur gelangweilt wie ich war. Jedenfalls habe ich absichtlich kopiert die API von async.eachSeries machen es einfach, zu verstehen, wie das funktioniert.

Einmal entfernen wir die Kommentare hier, wir haben nur 9 Zeilen code, die wiederverwendet werden können, für alle Arrays wir wollen den Prozess asynchron! Es wird sich nicht ändern, das ursprüngliche array, Fehler können geschickt werden an "Kurzschluss" der iteration, und eine separate callback genutzt werden können. Es funktioniert auch bei leeren arrays. Einiges an Funktionalität für nur 9 Zeilen 🙂

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

Nun erstellen wir eine Beispiel-async-Funktion zu verwenden, mit es. Wir werden fake die Verzögerung mit einem setTimeout von 500 ms hier.

//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, lasst uns sehen, wie Sie funktionieren !

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

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

Ausgang (500 ms Verzögerung vor jeder Ausgabe)

async cat !
async hat !
async wat !
done