node.js Generators & Jämför med återuppringningar

I den här handledningen ska vi lära oss om Generators och deras skillnader med återuppringningar

Vad är generatorer?

Generators har blivit ganska känd i node.js på senare tid och det är förmodligen på grund av vad de är kapabla att göra.

• Generators är funktionskörningar som kan avbrytas och återupptas vid en senare tidpunkt.
• Generators är användbara när du utför koncept som "lat utförande". Detta betyder i grunden att genom att avbryta utförandet och återuppta efter behag kan vi dra värden bara när vi behöver.

Generators har nedanstående 2 nyckelmetoder.

1. Avkastningsmetod – Avkastningsmetoden anropas i en funktion för att stoppa exekveringen av funktionen på den specifika raden där avkastningsmetoden anropas.
2. Nästa metod – Denna metod anropas från huvudapplikationen för att återuppta exekveringen av en funktion som har en avkastningsmetod. Utförandet av funktionen kommer att fortsätta till nästa avkastningsmetod eller till slutet av metoden.

Låt oss titta på ett exempel på hur generatorer kan användas.

I vårt exempel kommer vi att ha en enkel Add-funktion som lägger till 2 siffror, men vi kommer att fortsätta att stoppa metodexekveringen vid olika punkter för att visa upp hur generatorer kan användas.

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

var gen = Add(5);

gen.next();

gen.next(); 

Kodförklaring

1. Det första steget är att definiera vår generators "funktion". Observera att detta görs genom att lägga till en "*" till funktionsnyckelordet. Vi definierar då en funktion som heter Add som tar parametern x.
2. Nyckelordet avkastning är specifikt för generatorer. Detta gör det till en kraftfull konstruktion för att pausa en funktion mitt i vad som helst. Så här kommer funktionsexekveringen att stoppas tills vi anropar nästa()-funktionen, vilket kommer att göras i steg 4. Vid denna tidpunkt kommer värdet på x att bli 6 och exekveringen av funktionen stoppas.
3. Det är här vi först anropar generatorfunktionen och skickar värdet 5 till vår Add-funktion. Detta värde kommer att ersättas i parametern x i vår Add-funktion.
4. När vi anropar nästa()-funktionen kommer Add()-funktionen att återuppta exekveringen. När nästa programsats var y= yield(null) kommer att köras, kommer Add()-funktionen att sluta köras igen.
5. Nu efter att ha anropat nästa()-funktionen igen, kommer nästa satser att köras, och det kombinerade värdet av x=5 och y=6 kommer att läggas till och returneras.

Callbacks kontra generatorer

Generators används för att lösa problemet med det som kallas callback helvetet. Ibland blir callback-funktioner så kapslade under utvecklingen av en Node.js-applikation att det bara blir för komplicerat att använda callback-funktioner.

Det är här generatorer är användbara. Ett av de vanligaste exemplen på detta är när man skapar timerfunktioner.

Låt oss se nedanstående exempel på hur generatorer kan visa sig vara användbara över återuppringningar.

Vårt exempel kommer bara att skapa en enkel tidsfördröjningsfunktion. Vi skulle då vilja kalla denna funktion med en fördröjning på 1000, 2000 och 3000 ms.

Steg 1) Definiera vår återuppringningsfunktion med den nödvändiga tidsfördröjningskoden.

function Timedelay(ptime, callback) {

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

Kodförklaring

1. Här skapar vi en funktion som heter Timedelay med en parameter som heter ptime. Detta kommer att ta den nödvändiga fördröjning som vi vill införa i vår ansökan.
2. Nästa steg är att bara skapa ett meddelande som kommer att visas för användaren som säger att applikationen kommer att vara paus i dessa många millisekunder.

Steg 2) Låt oss nu titta på koden om vi inkluderade återuppringningar. Anta att vi ville inkludera återuppringningar baserat på värdet 1000, 2000 och 3000 millisekunder, koden nedan visar hur vi skulle behöva implementera dessa med hjälp av återuppringningar.

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

Kodförklaring

1. Vi kallar tidsfördröjningen som en återuppringning med 1000 som värde.
2. Därefter vill vi anropa Timedelay-funktionen igen med 2000 som värde.
3. Slutligen vill vi anropa Timedelay-funktionen igen med 3000 som värde.

Av ovanstående kod kan du se att det blir stökigare då vi vill börja anropa funktionen flera gånger.

Steg 3) Låt oss nu se hur man implementerar samma kod med hjälp av generatorer. Från koden nedan kan du nu se hur enkelt det har blivit att implementera Timedelay-funktionen med hjälp av generatorer.

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

Kodförklaring

1. Vi definierar först en generatorfunktion som kommer att användas för att anropa vår tidsfördröjningsfunktion.
2. Vi anropar avkastningsfunktionen tillsammans med tidsfördröjningsfunktionen med 1000 som parametervärde.
3. Vi anropar då avkastningsfunktionen tillsammans med tidsfördröjningsfunktionen med 2000 som parametervärde.
4. Slutligen anropar vi Yield-funktionen tillsammans med Timedelay-funktionen med 3000 som parametervärde.

Sammanfattning

Generators kan också användas för att lindra problemen med kapslade återuppringningar och hjälpa till att ta bort det som kallas återuppringningshelvetet. Generators används för att stoppa bearbetningen av en funktion. Detta åstadkoms genom att använda "yield"-metoden i den asynkrona funktionen.