Node.js
async.js
Suche…
Syntax
Jeder Rückruf muss mit folgender Syntax geschrieben werden:
Funktionsrückruf (err, result [, arg1 [, ...]])
Auf diese Weise müssen Sie den Fehler zuerst zurückgeben und können die spätere Verwendung nicht ignorieren.
nullist die Konvention ohne FehlerRückruf (null, myResult);
Ihre Rückrufe können mehr Argumente als err und result enthalten , sind jedoch nur für bestimmte Funktionen (Wasserfall, Seq, ...) nützlich.
Rückruf (null, myResult, myCustomArgument);
Und natürlich Fehler senden. Sie müssen es tun und Fehler behandeln (oder zumindest protokollieren).
Rückruf (err);
Parallel: Multitasking
async.parallel (Aufgaben, afterTasksCallback) führt eine Reihe von Aufgaben parallel aus und wartet auf das Ende aller Aufgaben (gemeldet vom Aufruf der Callback- Funktion).
Wenn Aufgaben abgeschlossen sind, ruft async den Hauptcallback mit allen Fehlern und Ergebnissen der Aufgaben auf.
function shortTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfShortTime');
}, 200);
}
function mediumTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfMediumTime');
}, 500);
}
function longTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfLongTime');
}, 1000);
}
async.parallel([
shortTimeFunction,
mediumTimeFunction,
longTimeFunction
],
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Ergebnis: ["resultOfShortTime", "resultOfMediumTime", "resultOfLongTime"] .
Rufen Sie async.parallel() mit einem Objekt auf
Sie können den Aufgaben- Array-Parameter durch ein Objekt ersetzen. In diesem Fall sind die Ergebnisse auch ein Objekt mit den gleichen Schlüsseln wie Aufgaben .
Es ist sehr nützlich, einige Aufgaben zu berechnen und jedes Ergebnis leicht zu finden.
async.parallel({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Ergebnis: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Mehrere Werte auflösen
Jeder parallelen Funktion wird ein Rückruf übergeben. Dieser Rückruf kann entweder einen Fehler als erstes Argument oder Erfolgswerte zurückgeben. Wenn für einen Rückruf mehrere Erfolgswerte übergeben werden, werden diese Ergebnisse als Array zurückgegeben.
async.parallel({
short: function shortTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfShortTime1', 'resultOfShortTime2');
}, 200);
},
medium: function mediumTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfMediumTime1', 'resultOfMeiumTime2');
}, 500);
}
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Ergebnis:
{
short: ["resultOfShortTime1", "resultOfShortTime2"],
medium: ["resultOfMediumTime1", "resultOfMediumTime2"]
}
.
Serie: unabhängiges Mono-Tasking
async.series (Aufgaben, afterTasksCallback) führt eine Reihe von Aufgaben aus. Jede Aufgabe wird nach der anderen ausgeführt . Wenn eine Aufgabe fehlschlägt, stoppt async sofort die Ausführung und springt in den Hauptcallback .
Wenn Aufgaben erfolgreich abgeschlossen wurden, rufen Sie asynchron den "Master" -Rückruf mit allen Fehlern und Ergebnissen der Aufgaben auf.
function shortTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfShortTime');
}, 200);
}
function mediumTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfMediumTime');
}, 500);
}
function longTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfLongTime');
}, 1000);
}
async.series([
mediumTimeFunction,
shortTimeFunction,
longTimeFunction
],
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Ergebnis: ["resultOfMediumTime", "resultOfShortTime", "resultOfLongTime"] .
Rufen Sie async.series() mit einem Objekt auf
Sie können den Aufgaben- Array-Parameter durch ein Objekt ersetzen. In diesem Fall sind die Ergebnisse auch ein Objekt mit den gleichen Schlüsseln wie Aufgaben .
Es ist sehr nützlich, einige Aufgaben zu berechnen und jedes Ergebnis leicht zu finden.
async.series({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Ergebnis: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Wasserfall: abhängiges Mono-Tasking
async.waterfall (Aufgaben, afterTasksCallback) führt eine Reihe von Aufgaben aus. Jede Aufgabe wird nach der anderen ausgeführt, und das Ergebnis einer Aufgabe wird an die nächste Aufgabe übergeben . Wenn async.series () fehlschlägt, stoppt async die Ausführung und ruft sofort den Hauptrückruf auf.
Wenn Aufgaben erfolgreich abgeschlossen wurden, rufen Sie asynchron den "Master" -Rückruf mit allen Fehlern und Ergebnissen der Aufgaben auf.
function getUserRequest(callback) {
// We simulate the request with a timeout
setTimeout(function() {
var userResult = {
name : 'Aamu'
};
callback(null, userResult);
}, 500);
}
function getUserFriendsRequest(user, callback) {
// Another request simulate with a timeout
setTimeout(function() {
var friendsResult = [];
if (user.name === "Aamu"){
friendsResult = [{
name : 'Alice'
}, {
name: 'Bob'
}];
}
callback(null, friendsResult);
}, 500);
}
async.waterfall([
getUserRequest,
getUserFriendsRequest
],
function(err, results) {
if (err) {
return console.error(err);
}
console.log(JSON.stringify(results));
});
Ergebnis: results enthält den zweiten Callback-Parameter der letzten Funktion des Wasserfalls, in diesem Fall friendsResult .
async.times (Um Schleife besser zu handhaben)
Um eine Funktion innerhalb einer Schleife in node.js auszuführen, können Sie eine for Schleife für kurze Schleifen verwenden. Die Schleife ist jedoch lang, die Verwendung der for Schleife erhöht die Verarbeitungszeit, wodurch der Knotenprozess hängen bleiben kann. In solchen Szenarien können Sie Folgendes verwenden: asycn.times
function recursiveAction(n, callback)
{
//do whatever want to do repeatedly
callback(err, result);
}
async.times(5, function(n, next) {
recursiveAction(n, function(err, result) {
next(err, result);
});
}, function(err, results) {
// we should now have 5 result
});
Dies wird parallel genannt. Wenn Sie es einzeln aufrufen möchten, verwenden Sie: async.timesSeries
async.each (Um das Datenfeld effizient zu behandeln)
Wenn wir ein Array von Daten behandeln wollen, ist es besser, async.each zu verwenden. Wenn wir etwas mit allen Daten durchführen möchten und den endgültigen Rückruf erhalten möchten, sobald alles fertig ist, ist diese Methode nützlich. Dies wird parallel behandelt.
function createUser(userName, callback)
{
//create user in db
callback(null)//or error based on creation
}
var arrayOfData = ['Ritu', 'Sid', 'Tom'];
async.each(arrayOfData, function(eachUserName, callback) {
// Perform operation on each user.
console.log('Creating user '+eachUserName);
//Returning callback is must. Else it wont get the final callback, even if we miss to return one callback
createUser(eachUserName, callback);
}, function(err) {
//If any of the user creation failed may throw error.
if( err ) {
// One of the iterations produced an error.
// All processing will now stop.
console.log('unable to create user');
} else {
console.log('All user created successfully');
}
});
Sie können async.eachSeries gleichzeitig verwenden
async.series (Ereignisse einzeln behandeln)
/ In async.series werden alle Funktionen in Reihe ausgeführt und die konsolidierten Ausgaben jeder Funktion werden an den endgültigen Rückruf übergeben. zB /
var async = required ('async'); async.series ([function (callback) {console.log ('First Execute ..'); callback (null, 'userPersonalData');}, function (callback) {console.log ('Second Execute ..'); callback (null, 'userDependentData');}], function (err, result) {console.log (result);});
//Ausgabe:
First Execute .. Second Execute .. ['userPersonalData', 'userDependentData'] // Ergebnis