Explication détaillée du traitement asynchrone à l'aide du nœud Async

Cette fois, je vais vous apporter une explication détaillée du traitement asynchrone du nœud Async. Quelles sont les précautions pour l'explication détaillée du traitement asynchrone du nœud Async. Ce qui suit est une explication pratique. cas, jetons un coup d'oeil.

J'ai étudié nodejs récemment, et ce que je ressens profondément, c'est... Les gens sur terre qui connaissent le code js savent que l'ordre de chargement de js est très important ! Très important ! ! Ensuite, la question se pose. Lors de l'écriture du nœud, de nombreuses interfaces seront demandées en arrière-plan (notre société transfère les données avec l'arrière-plan Java), et l'interface aura un rappel. Que dois-je faire avec autant de rappels... Chaque rappel renvoie. Comment gérer l'ordre de chargement est un problème... Il est impossible d'imbriquer... Nid... Faisons-le, ce sera très gênant ! ! Pourquoi n'y a-t-il pas de solution à un si gros problème ? C'est impossible... n'est-ce pas !

Module de traitement asynchrone asynchrone !

Voici ce que comprend le petit Sam :

L'installation est très simple, tout comme un module d'installation normal

L'installation est réussie ! L'étape suivante consiste à référencer par . Référencer le module dans le code :

var async = require('async');

. C'est OK de citer de cette façon ! Vous pouvez facilement utiliser le module objet asynchrone derrière le code !

J'ai vérifié la documentation officielle et trouvé qu'il y avait trop de méthodes dans ce module ! C'est vertigineux à voir...

Parlons de quelques méthodes qui, selon l'éditeur, sont plus couramment utilisées

série

1.series(tasks, [callback]) exécute séquentiellement les fonctions du tableau et de la collection. Lorsque la fonction précédente est exécutée, la fonction suivante sera exécutée immédiatement si la fonction déclenche une erreur, cela peut être vérifié dans la fonction de rappel. , sinon il continuera à être exécuté. Terminer les tâches

Ça ne sert à rien de trop parler, le code est le vrai père

Cas d'utilisation :

//tasks传的是一个数组函数
async.series([
  function(callback) {
  // do some stuff ...
  callback(null, 'one');
},
 function(callback) {
 // do some more stuff ...
 callback(null, 'two');
}],
// optional callback
//我觉得这里很重要err是上面两个函数的错误信息，而results这个参数是一个数组对象，它们的值是上面数组函数每个callback里面的参数。
function(err, results) {
// results is now equal to ['one', 'two']
});
// an example using an object instead of an          
//下面的代码其实跟上面的差不多，只是stasks传的是对象而不是数组
async.series({
one: function(callback) {
  setTimeout(function() {
    callback(null, 1);
  },
  200);
},
two: function(callback) {
  setTimeout(function() {
    callback(null, 2);
  },
  100);
 }
},
function(err, results) {
// results is now equal to: {one: 1, two: 2}
});

parallèle

2.parallel(tasks, [callback])  Exécutez des méthodes dans des tableaux et des collections en parallèle. Vous n'avez pas besoin d'attendre que la fonction précédente soit exécutée avant d'exécuter la fonction suivante. Si la fonction déclenche une erreur, vous pouvez la vérifier dans. la fonction de rappel

 async.parallel(
[
 function(callback) {
  setTimeout(function() {
     callback(null, 'one');
    },
  200);
 },
 function(callback) {
  setTimeout(function() {
    callback(null, 'two');
  },
  100);
 }
],
 // optional callback
 function(err, results) {
  // the results array will equal ['one','two'] even thoug
  // the second function had a shorter       
  timeout
 }
);

limiteparallèle

3.parallelLimit(tasks, limit, [callback]) L'utilisation est la même que 2, sauf qu'il y a une limite supplémentaire sur le nombre de tâches, le nombre maximum de tâches pouvant être exécutées en parallèle

pendant

4.whilst(test, fn, callback)  Équivalent à l'utilisation de while, le premier paramètre est la condition de vérification, le deuxième paramètre est la fonction d'exécution et le troisième paramètre est la fonction de rappel après vérification échoue, généralement Il est souvent utilisé dans les animations retardées

var count = 0;
 async.whilst(
 function () { return count < 5; },
 //验证成  功继续，失败进回调
 function (callback) {
   count++;
   setTimeout(callback, 1000);
 },
 function (err) {
   // 5 seconds have passed
 }
);

cascade

5.waterfall(tasks, [callback]) Les tâches sont exécutées dans l'ordre. Le rappel de la fonction précédente sera utilisé comme paramètre de la fonction suivante Si une tâche réussit un rappel d'erreur, la fonction suivante. ne sera pas exécuté

async.waterfall([
 function(callback){
   callback(null, 'one', 'two');
 },
 function(arg1, arg2, callback){
  // arg1 now equals 'one' and arg2 nowequals 'two'
   callback(null, 'three');
 },
 function(arg1, callback){
   // arg1 now equals 'three'
   callback(null, 'done');
 }
 ], function (err, result) {
  // result now equals 'done'  
});

composer

6.compose(fn1, fn2...) Ajoutez à la file d'attente dans l'ordre, exécutez dans l'ordre et utilisez le résultat de la fonction précédente comme valeur de la fonction suivante

 function add1(n, callback) {
 setTimeout(function () {
   callback(null, n + 1);
 }, 10);
 }
 function mul3(n, callback) {
 setTimeout(function () {
   callback(null, n * 3);
 }, 10);
}
var add1mul3 = async.compose(mul3, add1);
 add1mul3(4, function (err, result) {
// result now equals 15
});

Je crois que vous avez lisez le cas dans cet article Après avoir maîtrisé la méthode, veuillez prêter attention aux autres articles connexes sur le site Web php chinois pour un contenu plus passionnant !

Lecture recommandée :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!