Une analyse approfondie des rappels simultanés et asynchrones de NodeJ Processing_node.js

Il n'est pas exact de dire simultané et asynchrone. Il faut dire qu'il est asynchrone continu. La fonctionnalité asynchrone à thread unique de NodeJs empêche directement le rappel de déterminer le résultat final de l'exécution lorsque plusieurs opérations asynchrones sont effectuées en même temps. Donnez un exemple simple :

for(var i = 0; i < 5; i++) {
  fs.readFile('file', 'utf-8', function(error, data){});
} 

J'ai lancé 5 opérations asynchrones pour lire des fichiers d'affilée. La question est donc : comment puis-je m'assurer que toutes les opérations asynchrones ont été terminées ? Car les opérations ultérieures ne peuvent être effectuées qu’une fois qu’elles sont toutes exécutées. Je pense que les étudiants ayant une certaine expérience penseront à utiliser des méthodes de comptage, mais comment garantir un comptage correct est un autre problème. Réfléchissez bien :

Le rappel est une fonction qui définit le compteur sur 1 lors de chaque opération asynchrone et définit le compteur sur -1 à la fin de chaque opération asynchrone. Déterminez s'il faut exécuter le rappel en jugeant si le compteur est 0. Cette logique est très simple. Elle nécessite une variable globale relative au temps d'exécution et au temps de rappel comme compteur, et elle doit effectuer l'opération 1 lorsqu'elle est passée à la méthode asynchrone, puis renvoyer une fonction de rappel, ce qui est un peu compliqué. , mais jetez un œil à Utilisation avancée des fonctions Js :

var pending = (function() {
  var count = 0;
  return function() {
    count++;
    return function() {
      count--;
      if (count === 0) {
        // 全部执行完毕
      }
    }
  }
}); 

Lorsque ending est appelé, c'est ending(), par exemple :

var done = pending(); 

À ce moment, la variable de comptage count est initialisée à 0 et la fonction renvoyée est attachée à done. Si done() est exécuté à ce moment, que se passera-t-il ? S'agit-il d'exécuter directement la première fonction renvoyée par ending, c'est-à-dire : ending()() ? Quelle est cette exécution ? Tout d'abord, la variable de comptage count 1 est renvoyée, et une fonction est directement passée en rappel. à la méthode asynchrone. Lors de l'exécution de ce rappel, définissez d'abord la variable de comptage count-1, puis déterminez si le compte est 0. S'il est 0, cela signifie que toutes les exécutions asynchrones sont terminées, réalisant ainsi des opérations asynchrones continues avec le même. rappel.

La clé réside dans les deux retours En termes simples :

La première fonction de retour consiste à compter 1, puis renvoie la fonction qui nécessite un rappel

La deuxième fonction de retour est la fonction qui nécessite un rappel. Si elle est exécutée, elle comptera-1, puis déterminera si toutes les exécutions asynchrones sont terminées. Si elle est terminée, elle rappellera
.

Regardez un exemple pratique, rappel asynchrone pour lire plusieurs fichiers :

var fileName = ['1.html', '2.html', '3.html'];
var done = pending(function(fileData) {
  console.log('done');
  console.log(fielData);
});
for(var i = 0; i < fileName.lenght; i++) {
  fs.readFile(fileName[i], 'utf-8', done(fileName[i]));
}

Celui qui est terminé utilise la méthode en attente pour terminer la méthode que nous voulons rappeler et exécuter. Lorsque le compteur est à 0, il sera exécuté. Nous devons ensuite améliorer la méthode en attente :

.

var pending = (function(callback) {
  var count = 0;
  var returns = {};
  console.log(count);
  return function(key) {
    count++;
    console.log(count);
    return function(error, data) {
      count--;
      console.log(count);
      returns[key] = data;
      if (count === 0) {
        callback(returns);
      }
    }
  }
}); 

callback est notre fonction de rappel. Lorsque var done = ending(callback), done est en fait la première fonction de retour. Elle a un paramètre qui peut être utilisé comme indice de la valeur renvoyée, donc dans le corps de la boucle In done(. fileName[i]), le nom du fichier est transmis. Ce done() est exécuté directement. Après avoir compté 1, il renvoie la fonction de rappel à transmettre à la méthode asynchrone, comme mentionné précédemment, cette fonction de rappel déterminera si la fonction de rappel que nous voulons exécuter est basée sur la variable count. Et le contenu du fichier lui est transmis, c'est-à-dire qu'il est renvoyé. D'accord, allons-y, je pense que nous pouvons voir les résultats avec précision.

0
1
2
3
2
1
0
fait
{"1.html": "xxx", "2.html": "xxx", "3.html": "xxx"}

Cela se voit clairement à partir du décompte, de 0-3 à 0, puis notre fonction de rappel affiche terminé et le contenu du fichier.

Ce problème est résolu, il faut réfléchir à comment encapsuler et réutiliser une telle méthode, sinon, ne serait-il pas antiscientifique d'écrire en attente à chaque fois ?

Jetons un coup d'œil à la méthode de traitement d'UnJs (l'un de mes frameworks de développement Web basés sur NodeJs), appliquée aux opérations de sous-modèles dans l'analyse de modèles :

unjs.asyncSeries = function(task, func, callback) {
  var taskLen = task.length;
  if (taskLen <= 0) {
    return;
  }
  var done = unjs.pending(callback);
  for(var i = 0; i < taskLen; i++) {
    func(task[i], done);
  }
} 

asyncSeries a trois paramètres, ce qui signifie :

tâche : L'objet qui doit être traité, comme le fichier qui doit être lu, c'est une liste, si ce n'est pas une liste, ou si la longueur de la liste est 0, il ne sera pas exécuté

func : les méthodes asynchrones, telles que fs.readFile, y sont transmises

callback : La méthode que nous souhaitons rappeler

done est le même qu'avant. Il est passé à func, mais il n'est pas exécuté Parce que nous espérons que le côté application pourra contrôler les paramètres, nous laissons le côté application l'exécuter.

Regardez le fonctionnement lorsqu'il s'agit de sous-modèles :

var subTemplate = [];
var patt = /\{\% include \'(.+)\' \%\}/ig;
while(sub = patt.exec(data)) {
  var subs = sub;
  subTemplate.push([subs[0], subs[1]]);
}
unjs.asyncSeries(subTemplate, function(item, callback) {
  fs.readFile('./template/' + item[1], 'utf-8', callback(item[0]));
}, function(data) {
  for(var key in data) {
    html = html.replace(key, data[key]);
  }
}); 

La liste des sous-modèles est constituée de données générées sur la base de l'analyse des sous-modèles. Il s'agit d'un tableau bidimensionnel. La première valeur de chaque sous-élément est le texte appelant du sous-modèle, c'est-à-dire : {%. incluez 'header.html ' %} une telle chaîne, le deuxième paramètre est le nom du fichier de sous-modèle, c'est-à-dire : header.html

Le deuxième paramètre d'asyncSeries est le rappel, qui est en fait le troisième paramètre, qui est la méthode de rappel en attente de la fonction de rappel que nous voulons exécuter. Comme mentionné précédemment, dans asyncSeries, il n'est pas en cours d'exécution, mais est exécuté. ici, c'est-à-dire : callback(item[0]), avec des paramètres, car plus tard la chaîne appelant le sous-modèle dans le modèle parent sera remplacée par le contenu du sous-modèle correspondant en fonction de ce paramètre.

De cette façon, tant qu'un asynchrone continu est nécessaire, vous pouvez utiliser la méthode asyncSeries pour le gérer. En raison de la relation asynchrone, le déroulement du programme est un peu compliqué et il peut ne pas être facile à comprendre au début. Même si vous le connaissez, vous risquez de ne pas le comprendre du coup. , le rappel dans le deuxième paramètre est en fait généré par le troisième paramètre. Vous vous demandez peut-être, qu'est-ce que ce rappel exactement ? Il y a également deux retours en attente, qui ne sont pas faciles à comprendre et méritent d’être réfléchis davantage.

D'accord, le rappel asynchrone continu est effectué à l'aide des fonctionnalités avancées des fonctions Js. Cependant, la nature asynchrone de NodeJ rend vraiment le contrôle du programme très problématique, comme les opérations asynchrones continues qui nécessitent un transfert de valeur, etc. Tout cela peut être réalisé grâce à cette idée et à ces changements.

Le contenu ci-dessus est la connaissance du traitement des rappels simultanés et asynchrones dans NodeJs partagée par l'éditeur. J'espère qu'il vous plaira.