Verwendung von Promise zur Kapselung asynchroner Funktionen in NodeJS_node.js

Beim Schreiben von Node.js können kontinuierliche E/A-Vorgänge zu einem „Pyramiden-Albtraum“ führen, was die Wartung des Codes erschwert. Verwenden Sie das Versprechen von CommonJs, asynchrone Funktionen zu kapseln und eine einheitliche API zu verwenden um den Albtraum mehrerer Rückrufe loszuwerden.

Das von Node.js bereitgestellte nicht blockierende E/A-Modell ermöglicht es uns, Rückruffunktionen zur Abwicklung von E/A-Vorgängen zu verwenden. Wenn jedoch kontinuierliche E/A-Vorgänge erforderlich sind, werden Ihre Rückruffunktionen mehrfach verschachtelt, was den Code sehr unansehnlich und schwierig macht Und es kann eine Menge doppelten Code für die Fehlerbehandlung geben, die sogenannte „Pyramide of Doom“.

Code kopieren Der Code lautet wie folgt:

step1(function (value1) {
Schritt2(Wert1, Funktion(Wert2) {
         step3(value2, function(value3) {
              step4(value3, function(value4) {
// Mach etwas mit value4
            });
        });
});
});

Dies ist tatsächlich ein Problem mit dem Kontrollfluss von Node.js. Es gibt viele Lösungen für dieses Problem, z. B. die Verwendung von Async oder EventProxy usw. Das Thema dieses Artikels ist jedoch die Verwendung von Promise in der CommonJs-Spezifikation, um dieses Problem zu lösen Problem.

Was ist Versprechen?

Es gibt viele Promise-Spezifikationen von CommonJs. Wir diskutieren im Allgemeinen die Promise/A-Spezifikation, die das grundlegende Verhalten von Promise definiert.

Ein Promise ist ein Objekt, das normalerweise einen asynchronen Vorgang darstellt, der möglicherweise in der Zukunft abgeschlossen wird. Dieser Vorgang kann erfolgreich sein oder fehlschlagen, daher hat ein Promise-Objekt im Allgemeinen drei Zustände: Ausstehend, Erfüllt und Abgelehnt. Stellt einen unvollständigen, erfolgreichen Abschluss bzw. einen fehlgeschlagenen Vorgang dar. Sobald sich der Status des Promise-Objekts von „Ausstehend“ in „Erfüllt“ oder „Abgelehnt“ ändert, kann sein Status nicht mehr geändert werden.

Ein Promise-Objekt verfügt normalerweise über eine then-Methode, die es uns ermöglicht, den zurückgegebenen Wert nach einem möglichen Erfolg in der Zukunft oder dem Grund für den Fehler zu manipulieren. Die then-Methode sieht so aus:

promise.then(onFulfilled, onRejected)
Offensichtlich akzeptiert die then-Methode zwei Parameter, bei denen es sich normalerweise um zwei Funktionen handelt. Einer wird verwendet, um die Ergebnisse zu verarbeiten, nachdem die Operation fehlgeschlagen ist, und der andere wird verwendet, um die Gründe zu verarbeiten, nachdem die Operation fehlgeschlagen ist sind das Ergebnis nach Erfolg bzw. der Grund für Misserfolg. Wenn der an die Methode then übergebene Parameter keine Funktion ist, wird dieser Parameter ignoriert.

Der Rückgabewert der then-Methode ist ein Promise-Objekt. Diese Funktion ermöglicht es uns, den Aufruf zu verketten, um den Effekt der Flusssteuerung zu erzielen. Hier gibt es viele Detailthemen, etwa Wertübertragung oder Fehlerbehandlung. Die Spezifikation von Promise ist wie folgt definiert:

Der Rückgabewert der Funktion onFulfilled oder onRejected ist kein Promise-Objekt, dann wird dieser Wert als erster Parameter von onFulfilled in der nächsten Methode verwendet. Wenn der Rückgabewert ein Promise-Objekt ist, warum ist der Rückgabewert? der then-Methode das Promise-Objekt? Wenn in der Funktion onFulfilled oder onRejected eine Ausnahme ausgelöst wird, wird der Status des von der Methode then zurückgegebenen Promise-Objekts in „Rejected“ geändert. Wenn das Promise-Objekt then aufruft, wird das Error-Objekt als erster Parameter der Funktion onRejected verwendet
Wenn der Promise-Status „Erfüllt“ wird und in der then-Methode keine onFulfilled-Funktion bereitgestellt wird, wird der von der then-Methode zurückgegebene Promise-Objektstatus „Erfüllt“ und das erfolgreiche Ergebnis ist das Ergebnis des vorherigen Promise. Das Gleiche gilt für „Abgelehnt“.
Darüber hinaus werden onFulfilled und onRejected asynchron ausgeführt.

Standardimplementierung: q

Das Obige ist die Spezifikation von Promise, und was wir brauchen, ist seine Implementierung q ist eine Bibliothek mit besseren Implementierungsspezifikationen für Promise/A.

Zuerst müssen wir ein Promise-Objekt erstellen. Die Spezifikationen für die Erstellung von Promise-Objekten finden Sie in Promise/B. Ich werde hier keine detaillierte Erklärung geben, sondern einfach zum Code gehen.

Code kopieren Der Code lautet wie folgt:

Funktion(Flag){
         var defer = q.defer();
             fs.readFile("a.txt", function(err, data){
If(err) defer.reject(err);
                 else defer.resolve(data);
            });
                return defer.promise;
}

Die meisten Implementierungen von Promise sind bei der Erstellung von Promise ähnlich. Wenn der Wert erfolgreich abgerufen wird, wird defer.reject(reason) aufgerufen ) wird schließlich aufgerufen. Dieser Prozess kann als Aufruf von defer.resolve verstanden werden, um den Status des Versprechens in „Erfüllt“ zu ändern, und als Aufruf von defer.reject, um den Status des Versprechens in „Abgelehnt“ zu ändern.

Wie kann man Promise verwenden, um schönen Code zu schreiben, wenn man mit einer Reihe kontinuierlicher asynchroner Methoden konfrontiert wird? Schauen Sie sich das Beispiel unten an.

Code kopieren Der Code lautet wie folgt:

Versprechen0.then(Funktion(Ergebnis){
              // etwas tun
        Ergebnis zurückgeben;
}).then(function(result) {
              // etwas tun
          Rückgabeversprechen1;                                         }).then(function(result) {
              // etwas tun
}).catch(function(ex) {
console.log(ex);
}).finally(function(){
console.log("final");
});

Im obigen Code akzeptiert die then-Methode nur OnFulfilled, und die Catch-Methode ist tatsächlich then(null, OnRejected). In diesem Fall wird der Code dies tun, solange eine Reihe asynchroner Methoden immer Werte zurückgibt Wenn eine der asynchronen Methoden fehlschlägt oder eine Ausnahme auftritt, wird gemäß der CommonJs Promise-Spezifikation die Funktion im Catch ausgeführt. q stellt auch die Methode „final“ bereit, die wörtlich leicht zu verstehen ist. Das heißt, unabhängig von „resolve“ oder „reject“ wird die Funktion in „final“ ausgeführt.

Es scheint gut zu sein, der Code ist wartbarer und schöner. Was ist also, wenn Sie Parallelität wünschen?

Code kopieren Der Code lautet wie folgt:

​ q.all([Versprechen0, Versprechen1, Versprechen2]).spread(function(val0, val1, val2){
console.log(arguments);
                    }).then(function(){
console.log("done");
                  }).catch(function(err){
console.log(err);
                });

Q bietet außerdem eine API für Parallelität. Rufen Sie die Methode all auf und übergeben Sie ein Promise-Array, um den Kettenstil von then weiter zu verwenden. Es gibt auch Dinge wie q.nfbind, die die native API von Node.js in Promise konvertieren können, um das Codeformat zu vereinheitlichen, was ebenfalls sehr gut ist. Weitere APIs werden hier nicht im Detail beschrieben.

Fazit

In diesem Artikel wird hauptsächlich die Verwendung von Promise zur Lösung von Node.js-Kontrollflussproblemen vorgestellt. Promise kann jedoch auch auf das Front-End angewendet werden. EMCAScript6 bietet native API-Unterstützung. Es sollte darauf hingewiesen werden, dass Promise nicht die einzige Lösung ist, sondern auch eine benutzerfreundlichere Parallelitätskontroll-API bietet. Ich denke jedoch, dass Promise mehr Vorteile bei der Kapselung von Funktionen mit asynchronen Methoden bietet.

Okay, dieser Artikel endet hier, ich hoffe, er kann für alle hilfreich sein.