Node.js
async.js
Поиск…
Синтаксис
Каждый обратный вызов должен быть написан с помощью этого синтаксиса:
функция callback (err, result [, arg1 [, ...]])
Таким образом, вы вынуждены сначала вернуть ошибку и не можете игнорировать их обработку позже.
null- это соглашение в отсутствие ошибокcallback (null, myResult);
Ваши обратные вызовы могут содержать больше аргументов, чем err и результат , но это полезно только для определенного набора функций (водопад, seq, ...)
callback (null, myResult, myCustomArgument);
И, конечно, отправлять ошибки. Вы должны это сделать и обрабатывать ошибки (или, по крайней мере, регистрировать их).
обратный вызов (ERR);
Параллельно: многозадачность
async.parallel (tasks, afterTasksCallback) будет выполнять набор задач параллельно и ждать окончания всех задач (сообщенных вызовом функции обратного вызова ).
Когда задачи завершены, асинхронный вызов главного обратного вызова со всеми ошибками и всеми результатами задач.
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);
});
Результат: ["resultOfShortTime", "resultOfMediumTime", "resultOfLongTime"] .
Вызовите async.parallel() с объектом
Вы можете заменить параметр массива задач объектом. В этом случае результаты будут также объектом с теми же ключами, что и задачи .
Очень полезно вычислить некоторые задачи и легко найти каждый результат.
async.parallel({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Результат: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Разрешение нескольких значений
Каждой параллельной функции передается обратный вызов. Этот обратный вызов может либо вернуть ошибку в качестве первого аргумента, либо значения успеха после этого. Если обратный вызов передается несколько значений успеха, эти результаты возвращаются как массив.
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);
});
Результат:
{
short: ["resultOfShortTime1", "resultOfShortTime2"],
medium: ["resultOfMediumTime1", "resultOfMediumTime2"]
}
,
Серия: независимая монозагрузка
async.series (tasks, afterTasksCallback) выполнит набор задач. Каждая задача выполняется за другой . Если задача выходит из строя, async немедленно прекращает выполнение и переходит в основной обратный вызов .
Когда задачи завершены успешно, асинхронный вызов «мастер» обратного вызова со всеми ошибками и всеми результатами задач.
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);
});
Результат: ["resultOfMediumTime", "resultOfShortTime", "resultOfLongTime"] .
Вызовите async.series() с объектом
Вы можете заменить параметр массива задач объектом. В этом случае результаты будут также объектом с теми же ключами, что и задачи .
Очень полезно вычислить некоторые задачи и легко найти каждый результат.
async.series({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Результат: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Водопад: зависимая монозадание
async.waterfall (tasks, afterTasksCallback) выполнит набор задач. Каждая задача выполняется за другой, а результат задачи передается следующей задаче . Поскольку async.series () , если задача не выполняется, async прекращает выполнение и немедленно вызывает основной обратный вызов.
Когда задачи завершены успешно, асинхронный вызов «мастер» обратного вызова со всеми ошибками и всеми результатами задач.
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));
});
Результат: results содержат второй параметр обратного вызова последней функции водопада, который в этом случае является friendsResult .
async.times (лучше обращаться за цикл)
Чтобы выполнить функцию в цикле в Node.js, это хорошо использовать for петли для коротких циклов. Но цикл длинный, использование for цикла увеличивает время обработки, которое может привести к зависанию процесса узла. В таких сценариях вы можете использовать: 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
});
Это вызывается параллельно. Когда мы хотим называть его по одному, используйте: async.timesSeries
async.each (для эффективного управления массивом данных)
Когда мы хотим обрабатывать массив данных, лучше использовать async.each . Когда мы хотим что-то выполнить со всеми данными и хотим получить окончательный ответ, как только все будет сделано, этот метод будет полезен. Это обрабатывается параллельно.
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');
}
});
Чтобы сделать один за раз, можно использовать async.eachSeries
async.series (для обработки событий один за другим)
/ В async.series все функции выполняются последовательно, и объединенные выходы каждой функции передаются в окончательный обратный вызов. например,
var async = require ('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);});
//Выход:
Первое исполнение .. Второе выполнение .. ['userPersonalData', 'userDependentData'] // результат