Node.js
async.js
Sök…
Syntax
Varje återuppringning måste skrivas med denna syntax:
funktion återuppringning (fel, resultat [, arg1 [, ...]])
På det här sättet tvingas du att returnera felet först och kan inte ignorera att hantera dem senare.
nullär konventionen i avsaknad av felåteruppringning (null, myResult);
Dina återuppringningar kan innehålla fler argument än fel och resultat , men det är bara användbart för en specifik uppsättning funktioner (vattenfall, seq, ...)
återuppringning (null, myResult, myCustomArgument);
Och givetvis skicka fel. Du måste göra det och hantera fel (eller åtminstone logga in dem).
callback (err);
Parallell: multi-tasking
async.parallel (uppgifter, afterTasksCallback) kommer att utföra en uppsättning uppgifter parallellt och vänta på slutet av alla uppgifter (rapporteras av call of callback- funktionen).
När uppgifterna är klara, anropar async huvuduppringningen med alla fel och alla resultat av uppgifterna.
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);
});
Resultat: ["resultOfShortTime", "resultOfMediumTime", "resultOfLongTime"] .
Ring async.parallel() med ett objekt
Du kan byta ut uppgifter array parameter av ett föremål. I detta fall kommer resultat också att vara ett objekt med samma tangenter än uppgifter .
Det är mycket användbart att beräkna några uppgifter och enkelt hitta varje resultat.
async.parallel({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Resultat: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Lösa flera värden
Varje parallellfunktion ges en återuppringning. Denna återuppringning kan antingen returnera ett fel som det första argumentet eller framgångsvärdena efter det. Om en återuppringning ges flera framgångsvärden, returneras dessa resultat som en matris.
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);
});
Resultat :
{
short: ["resultOfShortTime1", "resultOfShortTime2"],
medium: ["resultOfMediumTime1", "resultOfMediumTime2"]
}
.
Serie: oberoende mono-tasking
async.series (uppgifter, afterTasksCallback) kommer att utföra en uppsättning uppgifter. Varje uppgift utförs efter en annan . Om en uppgift misslyckas, stoppar async genast exekveringen och hoppar in i huvuduppringningen .
När uppgifterna är framgångsrika, kallar async "master" återuppringning med alla fel och alla resultat av uppgifterna.
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);
});
Resultat: ["resultOfMediumTime", "resultOfShortTime", "resultOfLongTime"] .
Ring async.series() med ett objekt
Du kan byta ut uppgifter array parameter av ett föremål. I detta fall kommer resultat också att vara ett objekt med samma tangenter än uppgifter .
Det är mycket användbart att beräkna några uppgifter och enkelt hitta varje resultat.
async.series({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Resultat: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Vattenfall: beroende mono-tasking
async.waterfall (uppgifter, afterTasksCallback) kommer att utföra en uppsättning uppgifter. Varje uppgift utförs efter en annan, och resultatet av en uppgift överförs till nästa uppgift . Som async.series () , om en uppgift misslyckas, stoppar async körningen och ring omedelbart huvuduppringningen.
När uppgifterna är framgångsrika, kallar async "master" återuppringning med alla fel och alla resultat av uppgifterna.
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));
});
Resultat: results innehåller den andra återuppringningsparametern för vattenfallets sista funktion, som är friendsResult i så fall.
async.times (Att hantera för loop på bättre sätt)
För att köra en funktion i en slinga i node.js är det bra att använda en for loop för korta slingor. Men slingan är lång, att använda for loop kommer att öka bearbetningstiden vilket kan leda till att nodprocessen hänger. I sådana scenarier kan du använda: 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
});
Detta kallas parallellt. När vi vill kalla det en åt gången, använd: async.timesSeries
async.each (för att hantera en mängd data effektivt)
När vi vill hantera en mängd data är det bättre att använda async.each . När vi vill utföra något med all data och vill få den slutliga återuppringningen när allt är gjort, kommer den här metoden att vara användbar. Detta hanteras parallellt.
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');
}
});
Att göra en i taget kan använda async.eachSeries
async.series (Att hantera händelser en efter en)
/ I async.series körs alla funktioner i serie och de konsoliderade utgångarna från varje funktion överförs till den slutliga återuppringningen. t.ex.
var async = kräva ('async'); async.series ([function (callback) {console.log ('First Execute ..'); callback (null, 'userPersonalData');}, function (callback) {console.log ('Second Execute ..'); återuppringning (null, 'userDependentData');}], funktion (fel, resultat) {konsol.log (resultat);});
//Produktion:
First Execute .. Second Execute .. ['userPersonalData', 'userDependentData'] // result