Node.js Promise-Tutorial

In früheren Tutorials haben Sie Rückruffunktionen gesehen, die für asynchrone Ereignisse verwendet werden. Aber manchmal können Rückruffunktionen zu einem Albtraum werden, wenn sie verschachtelt werden und das Programm lang und komplex wird.

Was sind Versprechen?

Bevor wir mit Versprechen beginnen, werfen wir zunächst einen Blick auf die „Callback“-Funktionen in Node.js. Wir haben diese Rückruffunktionen in den vorherigen Kapiteln häufig gesehen, also gehen wir kurz eine davon durch.

Das folgende Beispiel zeigt einen Codeausschnitt, der zum Herstellen einer Verbindung zu einem verwendet wird MongoDB Datenbank und führen Sie einen Aktualisierungsvorgang für einen der Datensätze in der Datenbank durch.

1. Im obigen Code wird der Teil der Funktion (err,db) als Deklaration einer anonymen Funktion oder Rückruffunktion bezeichnet. Wenn der MongoClient eine Verbindung zum herstellt MongoDB Datenbank, wird es zur Rückruffunktion zurückkehren, sobald der Verbindungsvorgang abgeschlossen ist. In gewisser Weise finden die Verbindungsvorgänge also im Hintergrund statt, und wenn sie abgeschlossen sind, wird unsere Rückruffunktion aufgerufen. Denken Sie daran, dass dies einer der wichtigsten Punkte von Node.js ist, um viele Vorgänge gleichzeitig zu ermöglichen und somit keinen Benutzer daran zu hindern, einen Vorgang auszuführen.
2. Der zweite Codeblock wird ausgeführt, wenn die Rückruffunktion tatsächlich aufgerufen wird. Die Rückruffunktion aktualisiert nur einen Datensatz in unserem MongoDB Datenbank.

Was ist dann ein Versprechen? Nun, ein Versprechen ist lediglich eine Erweiterung der Rückruffunktionen in Node.js. Während des Entwicklungslebenszyklus kann es vorkommen, dass Sie mehrere Rückruffunktionen verschachteln müssen. Dies kann zu einem bestimmten Zeitpunkt ziemlich chaotisch und schwierig zu verwalten sein. Kurz gesagt ist ein Versprechen eine Verbesserung von Rückrufen, die darauf abzielt, diese Probleme zu lindern.

Die grundlegende Syntax eines Versprechens ist unten dargestellt;

var promise = doSomethingAync()
promise.then(onFulfilled, onRejected)

• „doSomethingAync“ ist eine beliebige Rückruf- oder asynchrone Funktion, die eine Art Verarbeitung durchführt.
• Dieses Mal gibt es beim Definieren des Rückrufs einen zurückgegebenen Wert, der als „Versprechen“ bezeichnet wird.
• Wenn ein Versprechen zurückgegeben wird, kann es zwei Ausgaben haben. Dies wird durch die „then-Klausel“ definiert. Entweder kann die Operation erfolgreich sein, was durch den Parameter „onFulfilled“ angezeigt wird. Oder es kann ein Fehler auftreten, was durch den Parameter „onRejected“ angezeigt wird.

Hinweis: Der Schlüsselaspekt eines Versprechens ist also der Rückgabewert. Beim Arbeiten mit normalen Rückrufen in Node.js gibt es kein Konzept für einen Rückgabewert. Aufgrund des Rückgabewerts haben wir mehr Kontrolle darüber, wie die Callback-Funktion definiert werden kann.

Im nächsten Thema sehen wir ein Beispiel für Versprechen und wie sie von Rückrufen profitieren.

Rückrufe auf Versprechen

Schauen wir uns nun ein Beispiel an, wie wir „Versprechen“ innerhalb einer Node.js-Anwendung verwenden können. Um Versprechen in einer Node.js-Anwendung verwenden zu können, muss zunächst das Modul „promise“ heruntergeladen und installiert werden.

Anschließend ändern wir unseren Code wie unten gezeigt, wodurch ein Mitarbeitername in der „Employee“-Sammlung mithilfe von Versprechen aktualisiert wird.

Schritt 1) Installieren der NPM-Module

Um Promises innerhalb einer Node JS-Anwendung zu verwenden, ist das Promise-Modul erforderlich. Führen Sie den folgenden Befehl aus, um das Promise-Modul zu installieren

NPM-Installationsversprechen

Schritt 2) Ändern Sie den Code, um Versprechen einzuschließen

var Promise = require('promise');
var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://localhost/EmployeeDB';

MongoClient.connect(url)
    .then(function(err, db) {
        db.collection('Employee').updateOne({
            "EmployeeName": "Martin"
        }, {
            $set: {
                "EmployeeName": "Mohan"
            }
        });
    }); 

Code-Erklärung:-

1. Der erste Teil besteht darin, das „Promise“-Modul einzubinden, das es uns ermöglicht, die Promise-Funktionalität in unserem Code zu verwenden.
2. Wir können jetzt die Funktion „then“ an unsere Funktion „MongoClient.connect“ anhängen. Dies bedeutet also, dass wir beim Herstellen der Verbindung zur Datenbank das danach definierte Code-Snippet ausführen müssen.
3. Schließlich definieren wir unser Code-Snippet, das den EmployeeName des Mitarbeiters mit dem Namen „Martin“ in „Mohan“ aktualisiert.

Hinweis: -

Wenn Sie jetzt den Inhalt Ihres überprüfen MongoDB In der Datenbank werden Sie feststellen, dass ein Datensatz mit dem EmployeeName „Martin“ auf „Mohan“ aktualisiert wird.

Um zu überprüfen, ob die Daten richtig in die Datenbank eingefügt wurden, müssen Sie die folgenden Befehle ausführen in MongoDB

1. Verwenden Sie EmployeeDB
2. db.Employee.find({EmployeeName :Mohan })

Die erste Anweisung stellt sicher, dass Sie mit der EmployeeDb-Datenbank verbunden sind. Die zweite Anweisung sucht nach dem Datensatz mit dem Mitarbeiternamen „Mohan“.

Umgang mit verschachtelten Versprechen

Bei der Definition von Versprechen ist zu beachten, dass die „thann“-Methode selbst ein Versprechen zurückgibt. In gewissem Sinne können Versprechen verschachtelt oder miteinander verkettet werden.

Im folgenden Beispiel verwenden wir die Verkettung, um zwei Rückruffunktionen zu definieren, die beide einen Datensatz in die einfügen MongoDB Datenbank.

(Hinweis: Verkettung ist ein Konzept, mit dem die Ausführung von Methoden miteinander verknüpft wird. Angenommen, Ihre Anwendung verfügt über zwei Methoden namens „MethodeA“ und „MethodeB“. Und die Logik war so, dass „MethodeB“ nach „MethodeA“ aufgerufen werden sollte, dann würden Sie die Ausführung so verketten, dass „MethodeB“ direkt nach „MethodeA“ aufgerufen wird.)

Der entscheidende Punkt in diesem Beispiel ist, dass der Code durch die Verwendung verschachtelter Promises sauberer, lesbarer und wartbarer wird.

var Promise = require('promise');
var MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://localhost/EmployeeDB';
MongoClient.connect(url)

.then(function(db) {
    db.collection('Employee').insertOne({
        Employeeid: 4,
        EmployeeName: "NewEmployee"
    })

    .then(function(db1) {
        db1.collection('Employee').insertOne({
            Employeeid: 5,
            EmployeeName: "NewEmployee1"
        })
    })
});

Code-Erklärung:-

1. Wir definieren jetzt zwei „Dann“-Klauseln, die nacheinander ausgeführt werden. In der ersten then-Klausel übergeben wir den Parameter „db“, der unsere Datenbankverbindung enthält. Anschließend verwenden wir die Sammlungseigenschaft der „db“-Verbindung, um Datensätze in die „Employee“-Sammlung einzufügen. Mit der Methode „insertOne“ wird das eigentliche Dokument in die Employee-Sammlung eingefügt.
2. Wir verwenden dann die 2^nd then-Klausel auch zum Einfügen eines weiteren Datensatzes in die Datenbank.

Wenn Sie jetzt den Inhalt Ihres überprüfen MongoDB In der Datenbank finden Sie die beiden eingefügten Datensätze MongoDB Datenbank.

Erstellen Sie ein individuelles Versprechen

Ein benutzerdefiniertes Versprechen kann mithilfe eines Knotenmoduls namens „q“ erstellt werden. Die „q“-Bibliothek muss mit dem Node-Paketmanager heruntergeladen und installiert werden. Nach Verwendung der 'q'-Bibliothek kann die Methode „denodeify“ aufgerufen werden, die bewirkt, dass jede Funktion zu einer Funktion wird, die ein Versprechen zurückgibt.

Im folgenden Beispiel erstellen wir eine einfache Funktion namens „Add“, die zwei Zahlen addiert. Wir konvertieren diese Funktion in eine Funktion, die ein Versprechen zurückgibt.

Sobald dies erledigt ist, verwenden wir das von der Add-Funktion zurückgegebene Versprechen, um eine Nachricht im console.log anzuzeigen.

Befolgen Sie die folgenden Schritte, um unsere benutzerdefinierte Funktion zur Rückgabe eines Versprechens zu erstellen.

Schritt 1) Installieren der NPM-Module

Um „q“ innerhalb einer Node JS-Anwendung zu verwenden, ist das Modul „q“ erforderlich. Um das Modul „q“ zu installieren, führen Sie den folgenden Befehl aus

npm install q

Schritt 2) Definieren Sie den folgenden Code, der zum Erstellen des benutzerdefinierten Versprechens verwendet wird.

Code-Erklärung:-

1. Das erste Bit besteht darin, die Bibliothek „q“ mithilfe des Schlüsselworts require einzubinden. Durch die Verwendung dieser Bibliothek können wir jede Funktion definieren, die einen Rückruf zurückgibt.
2. Wir erstellen eine Funktion namens Add, die zwei in den Variablen a und b definierte Zahlen addiert. Die Summe dieser Werte wird in der Variable c gespeichert.
3. Wir verwenden dann die q-Bibliothek, um unsere Add-Funktion zu denodefizieren (die Methode, mit der jede Funktion in eine Funktion umgewandelt wird, die ein Versprechen zurückgibt) oder unsere Add-Funktion anderweitig in eine Funktion umzuwandeln, die ein Versprechen zurückgibt.
4. Wir rufen jetzt unsere „Add“-Funktion auf und können aufgrund des vorherigen Schrittes, den wir durchgeführt haben, um die Add-Funktion zu entodeifizieren, einen Return-Promise-Wert erhalten.
5. Das Schlüsselwort „then“ wird verwendet, um anzugeben, dass bei erfolgreicher Ausführung der Funktion die Zeichenfolge „Additionsfunktion abgeschlossen“ im console.log angezeigt wird.

Wenn der obige Code ausgeführt wird, wird die Ausgabe „Additionsfunktion abgeschlossen“ wie unten gezeigt im console.log angezeigt.

Zusammenfassung

• Die Verwendung von Callback-Funktionen in Node.js hat seine Nachteile. Während des Entwicklungsprozesses kann die verschachtelte Verwendung von Rückruffunktionen manchmal dazu führen, dass der Code unübersichtlicher und schwieriger zu warten ist.
• Die meisten Probleme mit verschachtelten Callback-Funktionen können durch die Verwendung von Promises und Generatoren in node.js
• Ein Promise ist ein von einer asynchronen Funktion zurückgegebener Wert, der den Abschluss der von der asynchronen Funktion durchgeführten Verarbeitung anzeigt.
• Promises können ineinander verschachtelt werden, um den Code ansprechender und leichter wartbar zu gestalten, wenn eine asynchrone Funktion nach einer anderen asynchronen Funktion aufgerufen werden muss.