Node.js Generatoren & Vergleiche mit Rückrufen

Inhaltsverzeichnis:

Anonim

In diesem Tutorial lernen wir Generatoren und ihre Unterschiede zu Rückrufen kennen

Was sind Generatoren?

Generatoren sind in letzter Zeit in Node.js ziemlich berühmt geworden, und das wahrscheinlich aufgrund dessen, wozu sie in der Lage sind.

  • Generatoren sind Funktionsausführungen, die angehalten und zu einem späteren Zeitpunkt fortgesetzt werden können.
  • Generatoren sind nützlich, wenn Konzepte wie "Lazy Execution" ausgeführt werden. Dies bedeutet im Grunde, dass wir durch Anhalten der Ausführung und Wiederaufnahme nach Belieben Werte nur dann abrufen können, wenn dies erforderlich ist.

Generatoren haben die folgenden 2 Schlüsselmethoden

  1. Ertragsmethode - Die Ertragsmethode wird in einer Funktion aufgerufen, um die Ausführung der Funktion in der bestimmten Zeile anzuhalten, in der die Ertragsmethode aufgerufen wird.
  2. Nächste Methode - Diese Methode wird von der Hauptanwendung aufgerufen, um die Ausführung einer Funktion mit einer Ertragsmethode fortzusetzen. Die Ausführung der Funktion wird bis zur nächsten Ertragsmethode oder bis zum Ende der Methode fortgesetzt.

Schauen wir uns ein Beispiel an, wie Generatoren verwendet werden können.

In unserem Beispiel werden wir eine einfache Add-Funktion haben, die 2 Zahlen hinzufügt, aber wir werden die Methodenausführung an verschiedenen Punkten anhalten, um zu zeigen, wie Generatoren verwendet werden können.

function* Add(x) {yield x + 1;var y = yield(null);y = 6return x + y;}var gen = Add(5);gen.next();gen.next();

Code Erläuterung: -

  1. Der erste Schritt besteht darin, unsere Generatorfunktion zu definieren. Beachten Sie, dass dies durch Hinzufügen eines "*" zum Funktionsschlüsselwort erfolgt. Wir definieren dann eine Funktion namens Add, die einen Parameter von x annimmt.
  2. Das Yield-Schlüsselwort ist generatorspezifisch. Dies macht es zu einem leistungsstarken Konstrukt, um eine Funktion mitten in irgendetwas anzuhalten. Hier wird die Funktionsausführung angehalten, bis wir die next () -Funktion aufrufen, die in Schritt 4 ausgeführt wird. Zu diesem Zeitpunkt wird der Wert von x zu 6 und die Ausführung der Funktion wird gestoppt.
  3. Hier rufen wir zuerst die Generatorfunktion auf und senden den Wert 5 an unsere Add-Funktion. Dieser Wert wird im x-Parameter unserer Add-Funktion ersetzt.
  4. Sobald wir die next () -Funktion aufrufen, setzt die Add () -Funktion die Ausführung fort. Wenn die nächste Anweisung var y =ield (null) ausgeführt wird, wird die Ausführung der Funktion Add () erneut beendet.
  5. Nachdem Sie die Funktion next () erneut aufgerufen haben, werden die nächsten Anweisungen ausgeführt und der kombinierte Wert von x = 5 und y = 6 wird hinzugefügt und zurückgegeben.

Rückrufe gegen Generatoren

Generatoren werden verwendet, um das Problem der sogenannten Rückrufhölle zu lösen. Manchmal werden Rückruffunktionen während der Entwicklung einer Node.js-Anwendung so verschachtelt, dass die Verwendung von Rückruffunktionen einfach zu kompliziert wird.

Hier sind Generatoren nützlich. Eines der häufigsten Beispiele hierfür ist das Erstellen von Timerfunktionen.

Sehen wir uns das folgende Beispiel an, wie sich Generatoren bei Rückrufen als nützlich erweisen können.

In unserem Beispiel wird lediglich eine einfache Zeitverzögerungsfunktion erstellt. Wir möchten diese Funktion dann mit einer Verzögerung von 1000, 2000 und 3000 ms aufrufen.

Schritt 1) Definieren Sie unsere Rückruffunktion mit dem erforderlichen Zeitverzögerungscode.

function Timedelay(ptime, callback) {setTimeout(function() {callback("Pausing for " + ptime);}, time);}

Code Erläuterung: -

  1. Hier erstellen wir eine Funktion namens Timedelay mit einem Parameter namens ptime. Dies wird die notwendige Zeitverzögerung in Anspruch nehmen, die wir in unsere Anwendung einführen möchten.
  2. Der nächste Schritt besteht darin, einfach eine Nachricht zu erstellen, die dem Benutzer angezeigt wird und besagt, dass die Anwendung für diese vielen Millisekunden angehalten wird.

Schritt 2) Schauen wir uns nun den Code an, wenn wir Rückrufe integriert haben. Angenommen, wir wollten Rückrufe basierend auf dem Wert von 1000, 2000 und 3000 Millisekunden einbinden. Der folgende Code zeigt, wie wir diese mithilfe von Rückrufen implementieren müssten.

Timedelay(1000, function(message) {console.log(msg);Timedelay(2000, function(message) {console.log(msg);Timedelay(3000, function(message) {console.log(msg);})})})

Code Erläuterung: -

  1. Wir rufen das Timedelay als Rückruf mit 1000 als Wert auf.
  2. Als nächstes wollen wir die Timedelay-Funktion mit 2000 als Wert erneut aufrufen.
  3. Schließlich möchten wir die Timedelay-Funktion mit 3000 als Wert erneut aufrufen.

Anhand des obigen Codes können Sie erkennen, dass es unordentlicher wird, wenn wir die Funktion mehrmals aufrufen möchten.

Schritt 3) Nun wollen wir sehen, wie derselbe Code mithilfe von Generatoren implementiert wird. Aus dem folgenden Code können Sie nun ersehen, wie einfach es geworden ist, die Timedelay-Funktion mithilfe von Generatoren zu implementieren.

function* Messages() {console,log(yield(Timedelay(1000, function(){})));console,log(yield(Timedelay(2000, function(){})));console,log(yield(Timedelay(3000, function(){})));}

Code Erläuterung: -

  1. Wir definieren zunächst eine Generatorfunktion, mit der unsere Timedelay-Funktion aufgerufen wird.
  2. Wir rufen die Yield-Funktion zusammen mit der Timedelay-Funktion mit 1000 als Parameterwert auf.
  3. Wir rufen dann die Yield-Funktion zusammen mit der Timedelay-Funktion mit 2000 als Parameterwert auf.
  4. Schließlich rufen wir die Yield-Funktion zusammen mit der Timedelay-Funktion mit 3000 als Parameterwert auf.

Zusammenfassung

Generatoren können auch verwendet werden, um die Probleme mit verschachtelten Rückrufen zu lindern und das Entfernen der sogenannten Rückrufhölle zu unterstützen. Generatoren werden verwendet, um die Verarbeitung einer Funktion anzuhalten. Dies wird durch die Verwendung der 'Yield'-Methode in der asynchronen Funktion erreicht.