Elegante Handhabungsmethode von Nodejs asynchronem callback_node.js

Vorwort

Das größte Highlight von Nodejs ist das ereignisgesteuerte, nicht blockierende E/A-Modell, das Nodejs über starke Fähigkeiten zur gleichzeitigen Verarbeitung verfügt und sich sehr gut zum Schreiben von Netzwerkanwendungen eignet. Die meisten E/A-Vorgänge in Nodejs sind nahezu asynchron, das heißt, die Ergebnisse unserer E/A-Vorgänge müssen grundsätzlich in Rückruffunktionen verarbeitet werden, wie beispielsweise der folgenden Funktion, die den Dateiinhalt liest:

Code kopieren Der Code lautet wie folgt:

fs.readFile('/etc/passwd', function (err, data) {
if (err) throw err;
console.log(data);
});

Was sollen wir also tun, wenn wir zwei Dateien lesen und den Inhalt der beiden Dateien zur Verarbeitung zusammenführen? Die meisten Menschen, die js für kurze Zeit ausgesetzt waren, tun möglicherweise Folgendes:

Code kopieren Der Code lautet wie folgt:

fs.readFile('/etc/passwd', function (err, data) {
if (err) throw err;
fs.readFile('/etc/passwd2', function (err, data2) {
If (err) throw err;
// Hier die Daten von data und data2 verarbeiten
});
});

Wenn Sie es mit mehreren ähnlichen Szenarien zu tun haben, wäre es dann nicht so, dass die Rückruffunktionen Schicht für Schicht verschachtelt wären? Das ist es, was jeder oft als Rückrufpyramide oder Rückrufhölle bezeichnet (http://callbackhell.com/ ) ist auch das problematischste Problem für js-Neulinge.

Diese Art von verschachteltem Code bringt viele Probleme bei der Entwicklung mit sich, die sich hauptsächlich in Folgendem widerspiegeln:

1. Code-Möglichkeit wird schlimmer
2. Schwierigkeiten beim Debuggen
3. Schwierige Fehlerbehebung, wenn eine Anomalie auftritt

In diesem Artikel wird hauptsächlich erläutert, wie die oben genannten Probleme mit asynchronen Rückrufen ordnungsgemäß behandelt werden können.

Grundlegende Lösung: Asynchrone Rückrufe rekursiv verarbeiten

Wir können Rekursion als Ausführungskontrolltool für unseren Code verwenden. Kapseln Sie die auszuführenden Vorgänge in einer Funktion und steuern Sie den Ausführungsprozess des Codes durch rekursive Aufrufe in der Rückruffunktion. Kommen wir ohne weitere Umschweife zum letzten Code:

Code kopieren Der Code lautet wie folgt:

var fs = require('fs');
// Liste der zu verarbeitenden Dateien
var files = ['file1', 'file2', 'file3'];

Funktion parseFile () {
if (files.length == 0) {
Zurück;
}
var file = files.shift();
fs.readFile(file, function (err, data) {
// Dateidaten werden hier verarbeitet
ParseFile(); // Nach der Verarbeitung die nächste Datei durch rekursiven Aufruf verarbeiten
});
}

//Bearbeitung starten
parseFile();

Der obige Code hat als Beispiel die Dateien im Array sequentiell verarbeitet und dabei die rekursive Methode zur Steuerung des Ausführungsflusses des Codes eingeführt.

Es ist gut, es auf einige einfache Szenarien anzuwenden. Beispielsweise können wir diese Methode verwenden, um die Daten in einem Array nacheinander in der Datenbank zu speichern.

Einige einfache asynchrone Rückrufprobleme können durch Rekursion gelöst werden. Es ist jedoch immer noch nicht in der Lage, komplexe asynchrone Rückrufe zu verarbeiten (z. B. die Notwendigkeit, die Ergebnisse mehrerer asynchroner Vorgänge zu synchronisieren).

Toller Punkt: Verwenden Sie Bibliotheken von Drittanbietern wie Async, Q und Promise, um asynchrone Rückrufe zu verarbeiten

Um das Problem verschachtelter Rückrufe besser zu bewältigen, können Sie die Verwendung einiger Bibliotheken von Drittanbietern in Betracht ziehen, die auf die asynchrone Verarbeitung spezialisiert sind. Wenn Sie die Möglichkeit dazu haben, können Sie natürlich auch Ihr eigenes Hilfstool für die asynchrone Verarbeitung schreiben.

Die am häufigsten verwendeten Bibliotheken für die asynchrone Verarbeitung sind: async, q und Promise. Laut der Website npmjs.org ist Async am beliebtesten. Ich habe Async bereits verwendet und es ist in der Tat sehr praktisch. Der Kontrollfluss verschiedener asynchroner Verarbeitungen ist ebenfalls sehr gut implementiert.

Wir werden Async verwenden, um den anfänglichen Code zu verarbeiten, der zwei Dateien gleichzeitig liest. Das Beispiel sieht wie folgt aus:

Code kopieren Der Code lautet wie folgt:

var async = require('async')
, fs = require('fs');

async.parallel([
Funktion(Rückruf){
fs.readFile('/etc/passwd', function (err, data) {
Wenn (err) Rückruf(err);
​​callback(null, data);
});
},
Funktion(Rückruf){
fs.readFile('/etc/passwd2', function (err, data2) {
Wenn (err) Rückruf(err);
       callback(null, data2);
});
}
],
function(err, results){
// Die Daten von data und data2 werden hier verarbeitet und der Inhalt jeder Datei wird aus den Ergebnissen erhalten
});

Durch das Async-Modul kann der asynchrone Ausführungsprozess gut gesteuert werden, was auch als Lösung des Rückrufproblems auf allen Ebenen angesehen werden kann. Der Code ist klarer als zuvor, aber immer noch untrennbar mit der Rückruffunktion verbunden.

Denken Sie darüber nach: Wäre es nicht großartig, wenn Sie die asynchrone Verarbeitung ohne die Verwendung von Rückruffunktionen bewältigen könnten? Lassen Sie uns als Nächstes über die Verwendung der neuen Funktionen von ES6 sprechen, um dieses Ziel zu erreichen.

Seien Sie elegant: Nehmen Sie ES6 an, ersetzen Sie Rückruffunktionen und lösen Sie das Problem der Rückrufhölle

Es heißt, dass EcmaScript Harmony (ES6) viele neue Funktionen für js eingeführt hat. Studenten, die nicht viel über ES6 wissen, können es auf Baidu ausprobieren.

Um die neuen Funktionen von ES6 in NodeJS nutzen zu können, müssen Sie Version v0.11.x oder höher verwenden.

In diesem Artikel wird die Verwendung von Generator-Funktionen als Ersatz für Rückruffunktionen vorgestellt. Wissen Sie nichts über Generator? Hier können Sie einen Blick darauf werfen.

Hier werden die beiden Module co und thunkify verwendet. Sie können sie mit dem Befehl npm install installieren.

Nehmen wir das am Anfang dieses Artikels erwähnte Problem als Beispiel. Der Beispielcode für die Verwendung der Generatorfunktion lautet wie folgt:

Code kopieren Der Code lautet wie folgt:

var fs = require('fs')
, co = require('co')
, thunkify = require('thunkify');

var readFile = thunkify(fs.readFile);

co(function *() {
var test1 = yield readFile('test1.txt');
var test2 = yield readFile('test2.txt');
var test = test1.toString() test2.toString();
console.log(test);
})();

Die Behandlung von Ausnahmen im Code ist ebenfalls sehr einfach. Gehen Sie einfach wie folgt vor:

Code kopieren Der Code lautet wie folgt:

versuche es mit {
var test1 = yield readFile('test1.txt');
} Catch (e) {
// Ausnahmen hier behandeln
}

Ist dieser Code nicht viel eleganter? Ist es nicht großartig, mit asynchronem Code genauso umzugehen wie mit dem Schreiben von synchronem Code?

Für die Webentwicklung im Bereich NodeJS ist Express das beliebteste Framework. Erwähnenswert ist, dass TJ, ein Kernmitglied von Express, ein neues Web-Framework entwickelt hat, das als Web der nächsten Generation gilt Als Entwicklungsframework nutzt koa wirklich die Generatorfunktion von ES6, wodurch wir bei der Entwicklung von Websystemen vermeiden können, in Schichten von Rückrufen zu verfallen.

Zusammenfassung

Zitat eines Satzes aus der fibjs-Projektförderung: Weniger Rückruf, mehr Mädchen – Weniger Rückruf, mehr Mädchen