Eine eingehende Analyse des gleichzeitigen und asynchronen Rückrufs von NodeJs processing_node.js

Es ist nicht korrekt, gleichzeitig und asynchron zu sagen, es sollte kontinuierlich asynchron sein. Die asynchrone Single-Thread-Funktion von NodeJs führt direkt dazu, dass der Rückruf das endgültige Ausführungsergebnis nicht ermitteln kann, wenn mehrere asynchrone Vorgänge gleichzeitig ausgeführt werden. Geben Sie ein einfaches Beispiel:

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

Ich habe 5 asynchrone Vorgänge initiiert, um Dateien hintereinander zu lesen. Die Frage ist also: Wie kann ich sicherstellen, dass alle asynchronen Vorgänge abgeschlossen wurden? Denn die nachfolgenden Vorgänge können erst ausgeführt werden, nachdem sie alle ausgeführt wurden. Ich glaube, dass Schüler mit etwas Erfahrung über die Verwendung von Zählmethoden nachdenken werden, aber wie man sicherstellt, dass das Zählen korrekt ist, ist ein weiteres Problem. Überlegen Sie genau:

Rückruf ist eine Funktion, die den Zähler während jeder asynchronen Operation auf 1 setzt und den Zähler am Ende jeder asynchronen Operation auf -1 setzt. Bestimmen Sie, ob der Rückruf ausgeführt werden soll, indem Sie beurteilen, ob der Zähler 0 ist. Diese Logik ist sehr einfach. Sie erfordert eine globale Variable in Bezug auf die Ausführungszeit und die Rückrufzeit als Zähler und muss bei der Übergabe an die asynchrone Methode die Operation 1 ausführen und dann eine Funktion für den Rückruf zurückgeben, was etwas kompliziert ist , aber schauen Sie sich die erweiterte Verwendung von Js-Funktionen an:

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

Wenn pending aufgerufen wird, ist es pending(), zum Beispiel:

var done = pending(); 

Zu diesem Zeitpunkt wird die Zählvariable count auf 0 initialisiert und die zurückgegebene Funktion an done angehängt. Wenn done() zu diesem Zeitpunkt ausgeführt wird, was passiert? Soll die erste von pending zurückgegebene Funktion direkt ausgeführt werden, das heißt: pending()()? Zuerst wird die Zählvariable count 1 zurückgegeben und eine Funktion wird direkt als Rückruf übergeben Setzen Sie bei der Ausführung dieses Rückrufs zunächst die Zählvariable count-1 und bestimmen Sie dann, ob die Zählung 0 ist. Wenn sie 0 ist, bedeutet dies, dass die gesamte asynchrone Ausführung abgeschlossen ist und somit kontinuierliche asynchrone Vorgänge mit derselben erreicht werden Rückruf.

Der Schlüssel liegt in den beiden Renditen:

Die erste Rückgabefunktion besteht darin, 1 zu zählen und dann die Funktion zurückzugeben, die einen Rückruf benötigt

Die zweite Rückgabefunktion ist die Funktion, die einen Rückruf benötigt. Wenn sie ausgeführt wird, zählt sie 1 und ermittelt dann, ob die gesamte asynchrone Ausführung abgeschlossen ist. Wenn sie abgeschlossen ist, wird sie zurückgerufen

Sehen Sie sich ein praktisches Beispiel an, einen asynchronen Rückruf zum Lesen mehrerer Dateien:

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]));
}

Die fertige Methode verwendet die ausstehende Methode, um die Methode abzuschließen, die wir zurückrufen und ausführen möchten. Wenn der Zähler 0 ist, wird sie ausgeführt. Dann müssen wir die ausstehende Methode verbessern:

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 ist unsere Callback-Funktion. Wenn var done = pending(callback), ist done tatsächlich die erste Rückgabefunktion. Sie verfügt über einen Parameter, der als Index des zurückgegebenen Werts verwendet werden kann. In done( fileName[i]) wird der Dateiname übergeben. Diese done() wird direkt nach dem Zählen von 1 ausgeführt und gibt die Rückruffunktion zurück, die an die asynchrone Methode übergeben werden soll. Wie bereits erwähnt, bestimmt diese Rückruffunktion anhand der Zählvariablen, ob die Rückruffunktion ausgeführt werden soll. Und der Inhalt der Datei wird an ihn übergeben, also zurückgegeben. Okay, lassen Sie es uns ausführen. Ich glaube, wir können die Ergebnisse genau sehen.

0

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

Das ist deutlich an der Zählung zu erkennen, von 0-3 bis 0, und dann gibt unsere Rückruffunktion done und den Inhalt der Datei aus.

Dieses Problem ist gelöst. Wir müssen darüber nachdenken, wie wir eine solche Methode kapseln und wiederverwenden können. Wäre es sonst nicht unwissenschaftlich, jedes Mal ausstehend zu schreiben?

Werfen wir einen Blick auf die Verarbeitungsmethode von UnJs (einem meiner NodeJs-basierten Webentwicklungs-Frameworks), angewendet auf Untervorlagenoperationen bei der Vorlagenanalyse:

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 hat drei Parameter, was bedeutet:

Aufgabe: Das zu verarbeitende Objekt, z. B. die Datei, die gelesen werden muss, ist eine Liste. Wenn es keine Liste ist oder die Listenlänge 0 ist, wird es nicht ausgeführt

func: Asynchrone Methoden wie fs.readFile werden darüber übergeben

Rückruf: Die Methode, die wir zurückrufen möchten

Done ist das Gleiche wie zuvor. Es wird an func übergeben, aber nicht ausgeführt. Da wir hoffen, dass die Anwendungsseite die Parameter steuern kann, lassen wir es von der Anwendungsseite ausführen.

Sehen Sie sich die Funktionsweise beim Umgang mit Untervorlagen an:

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]);
  }
}); 

Die Liste der Untervorlagen besteht aus Daten, die auf der Grundlage der Analyse von Untervorlagen generiert wurden. Es handelt sich um ein zweidimensionales Array. Der erste Wert jedes Unterelements ist der aufrufende Text der Untervorlage, d. h. {%. Fügen Sie 'header.html ' %} eine solche Zeichenfolge ein. Der zweite Parameter ist der Name der Untervorlagendatei, d. h. header.html

Der zweite Parameter von asyncSeries ist der dritte Parameter, der die ausstehende Rückrufmethode der Rückruffunktion ist, die wir ausführen möchten. Wie bereits erwähnt, wird sie in asyncSeries nicht ausgeführt hier also: callback(item[0]), mit Parametern, da später die Zeichenfolge, die die Untervorlage in der übergeordneten Vorlage aufruft, basierend auf diesem Parameter durch den Inhalt der entsprechenden Untervorlage ersetzt wird.

Auf diese Weise können Sie die asyncSeries-Methode verwenden, um damit umzugehen, solange eine kontinuierliche Asynchronität erforderlich ist. Aufgrund der asynchronen Beziehung ist der Programmablauf etwas kompliziert, und selbst wenn Sie damit vertraut sind, ist es möglicherweise plötzlich nicht mehr wichtig , der Rückruf im zweiten Parameter wird tatsächlich vom dritten Parameter generiert. Sie fragen sich vielleicht, was genau dieser Rückruf ist. Außerdem sind noch zwei Rücksendungen anhängig, die nicht leicht zu verstehen sind und über die man sich genauer Gedanken machen muss.

Okay, der kontinuierliche asynchrone Rückruf wird mithilfe der erweiterten Funktionen von Js-Funktionen abgeschlossen. Allerdings macht die asynchrone Natur von NodeJs die Steuerung des Programms wirklich sehr problematisch, wie z. B. kontinuierliche asynchrone Vorgänge, die eine Werteübertragung erfordern usw. All dies kann durch diese Idee und Änderungen erreicht werden.

Bei dem oben genannten Inhalt handelt es sich um das vom Herausgeber geteilte Wissen über die gleichzeitige und asynchrone Rückrufverarbeitung. Ich hoffe, es gefällt Ihnen.