Node.js
async.js
Recherche…
Syntaxe
Chaque rappel doit être écrit avec cette syntaxe:
fonction callback (err, result [, arg1 [, ...]])
De cette façon, vous êtes obligé de renvoyer l'erreur en premier et vous ne pouvez pas ignorer leur traitement ultérieurement.
nullest la convention en l'absence d'erreurscallback (null, myResult);
Vos rappels peuvent contenir plus d’arguments que d’ erreurs et de résultats , mais ne sont utiles que pour un ensemble spécifique de fonctions (cascade, seq, ...)
callback (null, myResult, myCustomArgument);
Et, bien sûr, envoyer des erreurs. Vous devez le faire et gérer les erreurs (ou au moins les enregistrer).
rappel (err);
Parallèle: multi-tâches
async.parallel (tâches, afterTasksCallback) exécutera un ensemble de tâches en parallèle et attendra la fin de toutes les tâches (signalées par l'appel de la fonction de rappel ).
Lorsque les tâches sont terminées, async appelle le rappel principal avec toutes les erreurs et tous les résultats des tâches.
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);
});
Résultat: ["resultOfShortTime", "resultOfMediumTime", "resultOfLongTime"] .
Appelez async.parallel() avec un objet
Vous pouvez remplacer le paramètre tableau de tâches par un objet. Dans ce cas, les résultats seront également un objet avec les mêmes clés que les tâches .
C'est très utile pour calculer certaines tâches et trouver facilement chaque résultat.
async.parallel({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Résultat: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Résolution de plusieurs valeurs
Chaque fonction parallèle reçoit un rappel. Ce rappel peut renvoyer une erreur comme premier argument ou des valeurs de réussite après cela. Si un rappel est transmis à plusieurs valeurs de réussite, ces résultats sont renvoyés sous forme de tableau.
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);
});
Résultat :
{
short: ["resultOfShortTime1", "resultOfShortTime2"],
medium: ["resultOfMediumTime1", "resultOfMediumTime2"]
}
.
Série: mono-tâche indépendante
async.series (tasks, afterTasksCallback) exécutera un ensemble de tâches. Chaque tâche est exécutée après l'autre . Si une tâche échoue, async arrête immédiatement l'exécution et saute dans le rappel principal .
Lorsque les tâches sont terminées avec succès, async appelle le rappel "maître" avec toutes les erreurs et tous les résultats des tâches.
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);
});
Résultat: ["resultOfMediumTime", "resultOfShortTime", "resultOfLongTime"] .
Appelez async.series() avec un objet
Vous pouvez remplacer le paramètre tableau de tâches par un objet. Dans ce cas, les résultats seront également un objet avec les mêmes clés que les tâches .
C'est très utile pour calculer certaines tâches et trouver facilement chaque résultat.
async.series({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Résultat: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Cascade: mono-tâche dépendante
async.waterfall (tasks, afterTasksCallback) exécutera un ensemble de tâches. Chaque tâche est exécutée après l'autre et le résultat d'une tâche est transmis à la tâche suivante . En tant que async.series () , si une tâche échoue, async arrête l'exécution et appelle immédiatement le rappel principal.
Lorsque les tâches sont terminées avec succès, async appelle le rappel "maître" avec toutes les erreurs et tous les résultats des tâches.
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));
});
Résultat: le results contient le deuxième paramètre de rappel de la dernière fonction de la cascade, qui est friendsResult dans ce cas.
async.times (gérer mieux la boucle)
Pour exécuter une fonction dans une boucle en Node.js, il est bon d'utiliser une for boucle pour les boucles courtes. Mais la boucle est longue, utiliser for loop augmentera le temps de traitement, ce qui pourrait entraîner le blocage du processus de noeud. Dans de tels scénarios, vous pouvez utiliser: 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
});
Ceci est appelé en parallèle. Lorsque nous voulons l'appeler un à la fois, utilisez: async.timesSeries
async.each (pour gérer efficacement le tableau de données)
Lorsque nous voulons gérer un tableau de données, il est préférable d'utiliser async.each . Lorsque nous voulons effectuer quelque chose avec toutes les données et que nous voulons obtenir le rappel final une fois que tout est fait, cette méthode sera utile. Ceci est géré en parallèle.
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');
}
});
Pour faire un à la fois, vous pouvez utiliser async.eachSeries
async.series (Pour gérer les événements un par un)
/ Dans async.series, toutes les fonctions sont exécutées en série et les sorties consolidées de chaque fonction sont passées au rappel final. par exemple
var async = require ('async'); async.series ([function (callback) {console.log ('First Execute ..'); callback (null, 'userPersonalData');}, function (callback) {console.log ('Second Execute ..'); callback (null, 'userDependentData');}], fonction (err, result) {console.log (result);});
//Sortie:
First Execute .. Second Execute .. ['userPersonalData', 'userDependentData'] // résultat