Node.js
async.js
Zoeken…
Syntaxis
Elke callback moet met deze syntaxis worden geschreven:
functie callback (fout, resultaat [, arg1 [, ...]])
Op deze manier bent u gedwongen om de fout eerst te retourneren en kunt u niet negeren dat u ze later behandelt.
nullis de conventie zonder foutencallback (null, myResult);
Uw callbacks kunnen meer argumenten bevatten dan fout en resultaat , maar het is alleen nuttig voor een specifieke set functies (waterval, seq, ...)
callback (null, myResult, myCustomArgument);
En natuurlijk fouten verzenden. U moet het doen en fouten afhandelen (of ten minste registreren).
callback (err);
Parallel: multi-tasking
async.parallel (taken, afterTasksCallback) voert een reeks taken parallel uit en wacht het einde van alle taken (gemeld door de call of callback- functie).
Wanneer taken zijn voltooid, roept async de hoofdterugroep met alle fouten en alle resultaten van taken op.
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);
});
Resultaat: ["resultOfShortTime", "resultOfMediumTime", "resultOfLongTime"] .
Roep async.parallel() met een object
U kunt de parameter taken reeks te vervangen door een object. In dit geval zijn de resultaten ook een object met dezelfde toetsen als taken .
Het is erg handig om enkele taken te berekenen en elk resultaat gemakkelijk te vinden.
async.parallel({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Resultaat: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Meerdere waarden oplossen
Elke parallelle functie wordt teruggebeld. Deze callback kan een fout als eerste argument retourneren of succeswaarden daarna. Als een callback verschillende succeswaarden wordt doorgegeven, worden deze resultaten als een array geretourneerd.
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);
});
Resultaat :
{
short: ["resultOfShortTime1", "resultOfShortTime2"],
medium: ["resultOfMediumTime1", "resultOfMediumTime2"]
}
.
Serie: onafhankelijke mono-tasking
async.series (taken, afterTasksCallback) zal een reeks taken uitvoeren. Elke taak wordt na de andere uitgevoerd. Als een taak mislukt, stopt asynchroon de uitvoering en springt u in de hoofdterugroep .
Wanneer taken met succes zijn voltooid, roept async de "master" callback met alle fouten en alle resultaten van taken aan.
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);
});
Resultaat: ["resultOfMediumTime", "resultOfShortTime", "resultOfLongTime"] .
Roep async.series() met een object
U kunt de parameter taken reeks te vervangen door een object. In dit geval zijn de resultaten ook een object met dezelfde toetsen als taken .
Het is erg handig om enkele taken te berekenen en elk resultaat gemakkelijk te vinden.
async.series({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Resultaat: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Waterval: afhankelijke mono-tasking
async.waterfall (taken, afterTasksCallback) zal een reeks taken uitvoeren. Elke taak wordt na de andere uitgevoerd en het resultaat van een taak wordt doorgegeven aan de volgende taak . Async.series () , als een taak mislukt, stopt async de uitvoering en roept onmiddellijk de hoofdterugroep op.
Wanneer taken met succes zijn voltooid, roept async de "master" callback met alle fouten en alle resultaten van taken aan.
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));
});
Resultaat: results bevat de tweede callback-parameter van de laatste functie van de waterval, in dat geval friendsResult .
async.times (Om lus beter af te handelen)
Om een functie in een lus in node.js uit te voeren, is het prima om een for lus te gebruiken voor korte lussen. Maar de lus is lang, het gebruik van for lus verlengt de verwerkingstijd, waardoor het knooppuntproces mogelijk vastloopt. In dergelijke scenario's kunt u: asycn.times gebruiken
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
});
Dit wordt parallel genoemd. Gebruik: async.timesSeries als we het één voor één willen noemen
async.each (Om een reeks gegevens efficiënt te verwerken)
Als we een reeks gegevens willen verwerken, is het beter om async.each te gebruiken. Als we iets met alle gegevens willen uitvoeren en de laatste callback willen krijgen als alles klaar is, dan is deze methode nuttig. Dit wordt parallel behandeld.
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');
}
});
U kunt async.eachSeries één voor één gebruiken
async.series (Om gebeurtenissen één voor één af te handelen)
/ In async.series worden alle functies in serie uitgevoerd en worden de geconsolideerde uitgangen van elke functie doorgegeven aan de laatste callback. bijv. /
var async = vereisen ('async'); async.series ([function (callback) {console.log ('First Execute ..'); callback (null, 'userPersonalData');}, function (callback) {console.log ('Second Execute ..'); callback (null, 'userDependentData');}], functie (fout, resultaat) {console.log (resultaat);});
// Output:
Eerste uitvoering .. Tweede uitvoering .. ['userPersonalData', 'userDependentData'] // result