Node.js
async.js
Szukaj…
Składnia
Każde wywołanie zwrotne musi być napisane przy użyciu następującej składni:
funkcja zwrotna (err, wynik [, arg1 [, ...]])
W ten sposób musisz najpierw zwrócić błąd i nie możesz później zignorować ich obsługi.
nulljest konwencją przy braku błędówcallback (null, myResult);
Twoje wywołania zwrotne mogą zawierać więcej argumentów niż err i wynik , ale są użyteczne tylko dla określonego zestawu funkcji (wodospad, sekw., ...)
callback (null, myResult, myCustomArgument);
I oczywiście wysyłaj błędy. Musisz to zrobić i obsłużyć błędy (lub przynajmniej je zarejestrować).
callback (err);
Równolegle: wielozadaniowość
async.parallel (zadania, afterTasksCallback) wykona zestaw zadań równolegle i czeka na zakończenie wszystkich zadań (zgłaszane przez funkcję wywołania zwrotnego ).
Po zakończeniu zadań asynchronizuj główne wywołanie zwrotne ze wszystkimi błędami i wszystkimi wynikami zadań.
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);
});
Wynik: ["resultOfShortTime", "resultOfMediumTime", "resultOfLongTime"] .
Wywołaj async.parallel() z obiektem
Możesz zastąpić parametr tablicy zadań obiektem. W takim przypadku wyniki będą również obiektem z tymi samymi kluczami, co zadania .
Bardzo przydatne jest obliczenie niektórych zadań i łatwe znalezienie każdego wyniku.
async.parallel({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Wynik: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Rozwiązywanie wielu wartości
Każda funkcja równoległa jest przekazywana do oddzwaniania. To wywołanie zwrotne może zwrócić błąd jako pierwszy argument lub wartości sukcesu po tym. Jeśli wywołanie zwrotne zostanie przekazane kilka wartości sukcesu, wyniki są zwracane jako tablica.
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);
});
Wynik:
{
short: ["resultOfShortTime1", "resultOfShortTime2"],
medium: ["resultOfMediumTime1", "resultOfMediumTime2"]
}
.
Seria: niezależne mono-zadanie
async.series (zadania, afterTasksCallback) wykona zestaw zadań. Każde zadanie jest wykonywane po drugim . Jeśli zadanie się nie powiedzie, asynchronia natychmiast zatrzymuje wykonywanie i przeskakuje do głównego wywołania zwrotnego .
Po pomyślnym zakończeniu zadań asynchroniczne wywołanie zwrotne „master” ze wszystkimi błędami i wszystkimi wynikami zadań.
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);
});
Wynik: ["resultOfMediumTime", "resultOfShortTime", "resultOfLongTime"] .
Wywołaj async.series() z obiektem
Możesz zastąpić parametr tablicy zadań obiektem. W takim przypadku wyniki będą również obiektem z tymi samymi kluczami, co zadania .
Bardzo przydatne jest obliczenie niektórych zadań i łatwe znalezienie każdego wyniku.
async.series({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Wynik: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Wodospad: zależne zadanie jednozadaniowe
async.waterfall (zadania, afterTasksCallback) wykona zestaw zadań. Każde zadanie jest wykonywane po drugim, a wynik zadania jest przekazywany do następnego zadania . Jako async.series () , jeśli zadanie się nie powiedzie, asynchronicznie zatrzymaj wykonanie i natychmiast wywołaj główne wywołanie zwrotne.
Po pomyślnym zakończeniu zadań asynchroniczne wywołanie zwrotne „master” ze wszystkimi błędami i wszystkimi wynikami zadań.
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));
});
Wynik: results zawierają drugi parametr wywołania zwrotnego ostatniej funkcji wodospadu, czyli w tym przypadku friendsResult .
async.times (Aby lepiej obsługiwać pętlę)
Aby wykonać funkcję w pętli w node.js, dobrze jest używać for pętli na krótkie pętle. Ale pętla jest długa, użycie for pętli wydłuży czas przetwarzania, co może spowodować zawieszenie procesu węzła. W takich scenariuszach możesz użyć: 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
});
Nazywa się to równolegle. Kiedy chcemy wywoływać go pojedynczo, użyj: async.timesSeries
async.each (Aby efektywnie obsługiwać tablicę danych)
Gdy chcemy obsłużyć tablicę danych, lepiej użyć async.each . Gdy chcemy wykonać coś ze wszystkimi danymi i uzyskać ostateczne wywołanie zwrotne, gdy wszystko zostanie wykonane, ta metoda będzie przydatna. Jest to obsługiwane równolegle.
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');
}
});
Aby to zrobić pojedynczo, można użyć async.eachSeries
async.series (do obsługi zdarzeń jeden po drugim)
/ W async.series wszystkie funkcje są wykonywane szeregowo, a skonsolidowane dane wyjściowe każdej funkcji są przekazywane do ostatecznego wywołania zwrotnego. np. /
var async = wymagany („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 (wynik);});
//Wynik:
Pierwsze wykonanie .. Drugie wykonanie .. ['userPersonalData', 'userDependentData'] // wynik