Node.js Generators & Vergleichen mit Rückrufen

In diesem Tutorial werden wir mehr darüber erfahren Generators und ihre Unterschiede zu Callbacks

Was sind generators?

Generators sind in ziemlich berühmt geworden Node.js in jüngster Zeit und das liegt wahrscheinlich an dem, wozu sie fähig sind.

  • Generators sind Funktionsausführungen, die angehalten und wieder aufgenommen werden können later Punkt.
  • Generators sind nützlich, wenn Konzepte wie „Lazy Execution“ umgesetzt werden. Dies bedeutet im Grunde, dass wir durch das Aussetzen und Wiederaufnehmen der Ausführung nach Belieben nur dann Werte abrufen können, wenn dies erforderlich ist.

Generators haben die folgenden 2 Schlüsselmethoden.

  1. Ertragsmethode – Die Yield-Methode wird in einer Funktion aufgerufen, um die Ausführung der Funktion in der spezifischen Zeile anzuhalten, in der die Yield-Methode aufgerufen wird.
  2. Nächste Methode – Diese Methode wird von der Hauptanwendung aufgerufen, um die Ausführung einer Funktion fortzusetzen, die über eine yield-Methode verfügt. Die Ausführung der Funktion wird bis zur nächsten Ertragsmethode oder bis zum Ende der Methode fortgesetzt.

Schauen wir uns ein Beispiel dafür an generators können verwendet werden.

In unserem Beispiel werden wir eine einfache Add-Funktion haben, die zwei Zahlen hinzufügt, aber wir werden die Ausführung der Methode an verschiedenen Stellen anhalten, um zu zeigen, wie das geht generators können verwendet werden.

Node.js Generators

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

var gen = Add(5);

gen.next();

gen.next(); 

Code Erklärung

  1. Der erste Schritt besteht darin, unser zu definieren generator "Funktion". Beachten Sie, dass dies durch Hinzufügen eines „*“ zum Funktionsschlüsselwort erfolgt. Anschließend definieren wir eine Funktion namens Add, die den Parameter x annimmt.
  2. Das Schlüsselwort yield ist spezifisch für generatorS. Dies macht es zu einem leistungsstarken Konstrukt, um eine Funktion mitten in etwas anzuhalten. Hier wird die Funktionsausführung angehalten, bis wir die Funktion next() aufrufen, was in Schritt 4 erfolgt. An diesem Punkt wird der Wert von x zu 6 und die Ausführung der Funktion wird gestoppt.
  3. Hier rufen wir zuerst an generator Funktion und senden Sie den Wert 5 an unsere Add-Funktion. Dieser Wert wird in den x-Parameter unserer Add-Funktion eingesetzt.
  4. Sobald wir die Funktion next() aufrufen, setzt die Funktion Add() die Ausführung fort. Wenn die nächste Anweisung var y= yield(null) ausgeführt wird, wird die Ausführung der Funktion Add() erneut gestoppt.
  5. Nach dem erneuten Aufruf der Funktion next() werden nun die nächsten Anweisungen ausgeführt und der kombinierte Wert von x=5 und y=6 addiert und zurückgegeben.

Rückrufe vs. generators

Generators werden verwendet, um das Problem der sogenannten Callback-Hö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.

Das ist wo generators sind nützlich. Eines der häufigsten Beispiele hierfür ist die Erstellung von Timerfunktionen.

Sehen wir uns das folgende Beispiel an generators können sich gegenüber Rückrufen als nützlich erweisen.

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.

Rückrufe vs. Generators

function Timedelay(ptime, callback) {

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

Code Erklärung

  1. Hier erstellen wir eine Funktion namens Timedelay mit einem Parameter namens ptime. Dies nimmt die notwendige Zeitverzögerung in Anspruch, die wir in unserer Bewerbung 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 viele Millisekunden pausiert.

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

Rückrufe vs. Generators

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

Code Erklärung

  1. Wir rufen die Zeitverzögerung als Rückruf mit dem Wert 1000 auf.
  2. Als nächstes wollen wir die Timedelay-Funktion erneut mit 2000 als Wert aufrufen.
  3. Abschließend wollen wir die Timedelay-Funktion noch einmal mit 3000 als Wert aufrufen.

Aus dem obigen Code können Sie ersehen, dass es chaotischer wird, wenn wir die Funktion mehrmals aufrufen möchten.

Schritt 3) Sehen wir uns nun an, wie man denselben Code mit implementiert generatorS. Anhand des folgenden Codes können Sie nun sehen, wie einfach es geworden ist, die Timedelay-Funktion mit zu implementieren generators.

Rückrufe vs. Generators

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

Code Erklärung

  1. Wir definieren zunächst a generator Funktion, die zum Aufrufen unserer Timedelay-Funktion verwendet wird.
  2. Wir rufen die Yield-Funktion zusammen mit der Timedelay-Funktion mit 1000 als Parameterwert auf.
  3. Anschließend rufen wir 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

Generators können auch verwendet werden, um die Probleme mit verschachtelten Rückrufen zu lindern und dabei zu helfen, die sogenannte Rückrufhölle zu beseitigen. Generators werden verwendet, um die Verarbeitung einer Funktion anzuhalten. Dies wird durch die Verwendung der „Yield“-Methode in a erreichtsyncchronische Funktion.