I den här handledningen ska vi lära oss mer om generatorer och deras skillnader med återuppringningar
Vad är generatorer?
Generatorer har blivit ganska kända i Node.js på senare tid och det antagligen på grund av vad de kan göra.
- Generatorer är funktionskörningar som kan avbrytas och återupptas vid ett senare tillfälle.
- Generatorer är användbara när man utför begrepp som ”lat utförande”. Detta innebär i grund och botten att genom att stänga av körningen och återuppta efter eget val kan vi bara dra värden när vi behöver.
Generatorer har nedanstående två viktiga metoder
- Avkastningsmetod - Avkastningsmetoden kallas i en funktion för att stoppa utförandet av funktionen vid den specifika rad där avkastningsmetoden kallas.
- Nästa metod - Den här metoden kallas från huvudapplikationen för att återuppta körningen av en funktion som har en avkastningsmetod. Körningen av funktionen fortsätter 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 Lägg till-funktion som kommer att lägga till två nummer, men vi kommer att fortsätta att stoppa metodkörningen vid olika punkter för att visa hur generatorer kan användas.
function* Add(x) {yield x + 1;var y = yield(null);y = 6return x + y;}var gen = Add(5);gen.next();gen.next();
Kodförklaring: -
- Det första steget är att definiera vår generatorfunktion. Observera att detta görs genom att lägga till ett "*" i funktionsnyckelordet. Vi definierar sedan en funktion som heter Add som tar parametern x.
- Avkastningsnyckelordet är specifikt för generatorer. Detta gör det till en kraftfull konstruktion för att pausa en funktion mitt i allt. Så här kommer funktionskörningen att stoppas tills vi åberopar nästa () funktion, vilket kommer att göras i steg 4. Vid denna tidpunkt kommer värdet på x att bli 6 och körningen av funktionen kommer att stoppas.
- Det är här vi först anropar generatorfunktionen och skickar värdet 5 till vår Lägg till-funktion. Detta värde kommer att ersättas med x-parametern i vår Lägg till-funktion.
- När vi kallar nästa () -funktion kommer funktionen Lägg till () att återuppta körningen. När nästa uttalande var y = avkastning (null) kommer att köras kommer funktionen Lägg till () att sluta köras igen.
- Efter att ha anropat nästa () -funktionen igen kommer nästa uttalanden att köras och det kombinerade värdet x = 5 och y = 6 läggs till och returneras.
Återuppringningar mot generatorer
Generatorer används för att lösa problemet med vad som kallas callback-helvete. Ibland blir återuppringningsfunktioner så kapslade under utvecklingen av ett Node.js-program att det bara blir för komplicerat att använda återuppringningsfunktioner.
Det är här generatorer är användbara. Ett av de vanligaste exemplen på detta är när du skapar timerfunktioner.
Låt oss se nedanstående exempel på hur generatorer kan visa sig vara användbara vid återuppringningar.
Vårt exempel skapar bara en enkel tidsfördröjningsfunktion. Vi skulle då vilja kalla den här funktionen med en fördröjning på 1000, 2000 och 3000 ms.
Steg 1) Definiera vår återuppringningsfunktion med nödvändig tidsfördröjningskod.
function Timedelay(ptime, callback) {setTimeout(function() {callback("Pausing for " + ptime);}, time);}
Kodförklaring: -
- Här skapar vi en funktion som heter Timedelay med en parameter som heter ptime. Detta tar den nödvändiga tidsfördröjningen som vi vill införa i vår ansökan.
- Nästa steg är att bara skapa ett meddelande som kommer att visas för användaren som säger att applikationen kommer att pausa under så många millisekunder.
Steg 2) Låt oss nu titta på koden om vi använde återuppringningar. Antag att vi ville ta med återuppringningar baserat på värdet 1000, 2000 och 3000 millisekunder, nedanstående kod 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: -
- Vi kallar Timedelay som en återuppringning med 1000 som värde.
- Därefter vill vi kalla Timedelay-funktionen igen med 2000 som värde.
- Slutligen vill vi kalla Timedelay-funktionen igen med 3000 som värde.
Från ovanstående kod kan du se att det blir mer rörligt eftersom vi vill börja ringa 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 generatorer.
function* Messages() {console,log(yield(Timedelay(1000, function(){})));console,log(yield(Timedelay(2000, function(){})));console,log(yield(Timedelay(3000, function(){})));}
Kodförklaring: -
- Vi definierar först en generatorfunktion som kommer att användas för att kalla vår Timedelay-funktion.
- Vi kallar avkastningsfunktionen tillsammans med Timedelay-funktionen med 1000 som parametervärde.
- Vi ringer sedan avkastningsfunktionen tillsammans med Timedelay-funktionen med 2000 som parametervärde.
- Slutligen kallar vi avkastningsfunktionen tillsammans med Timedelay-funktionen med 3000 som parametervärde.
Sammanfattning
Generatorer kan också användas för att lindra problemen med kapslade återuppringningar och hjälpa till att ta bort det som kallas återuppringningshelvet. Generatorer används för att stoppa behandlingen av en funktion. Detta åstadkommes genom användning av 'avkastningsmetoden' i den asynkrona funktionen.