node.js Generators & Sammenlign med tilbagekald

I denne gennemgang ser vi på generatorer og hvordan de adskiller sig fra callbacks.

Hvad er generatorer?

Generatorblev populær i node.js på grund af hvad de er i stand til at gøre.

• Generators er funktionsudførelser, der kan suspenderes og genoptages på et senere tidspunkt.
• Generators er nyttige til koncepter som "doven udførelse". Ved at suspendere udførelsen og genoptage den efter behov, hentes værdier kun, når der er behov for dem.

Generators har de to vigtigste metoder nedenfor.

1. Udbyttemetode — kaldes inde i en funktion for at stoppe udførelsen på den præcise linje, hvor yield kommer til syne.
2. Næste metode — kaldet fra hovedapplikationen for at genoptage en funktion, der har givet afkald. Udførelsen fortsætter indtil den næste yield, eller indtil funktionen er slut.

Lad os se på et eksempel på, hvordan generatorer kan bruges. Eksemplet definerer en simpel Add-funktion, der lægger to tal sammen og stopper udførelsen på forskellige punkter for at vise, hvordan generatorer opfører sig.

function* Add(x) {
    yield x + 1;
    // The value passed into the second next() call lands here
    var y = yield(null);
    return x + y;
}

var gen = Add(5);

gen.next();      // runs to the first yield, returns { value: 6, done: false }
gen.next(6);     // resumes, y becomes 6, returns { value: 11, done: true }

Code Forklaring

1. Det første trin er at definere generatorfunktionen. Bemærk * tilføjet til function nøgleord. Funktionen kaldes Add og tager en parameter x.
2. yield Nøgleordet er specifikt for generatorer og sætter funktionen på pause midt i udførelsen. Udførelsen stopper her indtil next() påkaldes.
3. Den anden yield både sætter funktionen på pause og modtager en værdi: hvad der end sendes til følgende next() opkaldet bliver værdien af y.
4. Opkald gen.next() første gang kører funktionen op til den første yieldOpkald gen.next(6) genoptager det, tildeler 6 til y, og returnerer x + y.

⚠️ Rettelse: Den oprindelige liste indeholdt linjen y = 6 umiddelbart efter var y = yield(null);Den tildeling overskriver enhver værdi next() forsyninger, hvilket modvirker formålet med eksemplet og gør det andet yield meningsløs. Værdien gives nu videre gennem gen.next(6), hvilket er sådan en generator rent faktisk modtager data fra den, der ringer op.

Tilbagekald vs. generatorer

Generators løser problemet kendt som callback-helvede. Callback-funktioner bliver nogle gange så dybt indlejrede under udviklingen af ​​en Node.js-applikation, at de er vanskelige at følge.

Det er her, generatorer hjælper. Et af de mest almindelige eksempler er oprettelse af timerfunktioner. Eksemplet nedenfor bygger en simpel tidsforsinkelsesfunktion og kalder den derefter med forsinkelser på 1000, 2000 og 3000 ms.

Trin 1) Definer callback-funktionen med den nødvendige tidsforsinkelseskode.

function Timedelay(ptime, callback) {

    setTimeout(function() {

        callback("Pausing for " + ptime);

    }, ptime);   // the delay must use ptime, the parameter name
}

Code Forklaring

1. En funktion kaldet Timedelay er oprettet med en parameter ptime, som angiver antallet af millisekunder, der skal holdes pause i.
2. setTimeout venter i det antal millisekunder og kalder derefter det angivne callback.

⚠️ Rettelse: den oprindelige kode, der blev bestået time som det andet argument til setTimeout, men ingen variabel navngivet time findes — parameteren er ptimeSom skrevet kaster det ReferenceError: time is not defined.

Trin 2) Overvej nu koden ved hjælp af callbacks. For at kæde forsinkelser på 1000, 2000 og 3000 millisekunder sammen, skal callbacks indlejres inden i hinanden.

Timedelay(1000, function(message) {

    console.log(message);

    Timedelay(2000, function(message) {

        console.log(message);

        Timedelay(3000, function(message) {

            console.log(message);
        });
    });
});

Code Forklaring

1. Timedelay kaldes som et callback med værdien 1000.
2. Inde i det tilbagekald, Timedelay kaldes igen med 2000.
3. Inde i den ene, Timedelay kaldes en tredje gang med 3000.

⚠️ Rettelse: hvert tilbagekald i den oprindelige logføring msg, men parameteren er navngivet messageAlle tre linjer kastede ReferenceError: msg is not defined.

Fra koden ovenfor kan du se, at det bliver mere rodet med hvert yderligere kald — denne indlejring er, hvad callback-helvede beskriver.

Trin 3) Se nu den samme opførsel skrevet med generatorer. Sekvensen læses som tre flade linjer i stedet for tre niveauer af indlejring.

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

Code Forklaring

1. En generatorfunktion er defineret til at kalde Timedelay funktion.
2. yield bruges med Timedelay og 1000 som parameterværdi.
3. yield bruges igen med 2000, og endnu en gang med 3000.

⚠️ Rettelse: originalen skrev console,log(...) med et komma i stedet for et punktum på alle tre linjer, hvilket er en syntaksfejl og forhindrer filen i at blive parset overhovedet.

Sådan kører du en Generator med en løberfunktion

Generatoren ovenfor er smukt læsbar, men kan ikke gøre noget i sig selv. Dette er den detalje, de fleste forklaringer udelader, og det er grunden til, at den flade version kan ligne magi. En generator er en maskine, der er sat på pause, og noget skal blive ved med at trykke på knappen. Opkald Messages() opretter blot generatorobjektet og vender tilbage med det samme; ingen timer starter nogensinde, og intet udskrives.

Den manglende brik er en løber: en lille funktion, der kalder next(), venter på, at det asynkrone arbejde er færdigt, og kalder derefter next() igen med resultatet.

// Timedelay now hands its result back to the runner
function Timedelay(ptime) {
    return function(resume) {
        setTimeout(function() {
            resume("Pausing for " + ptime);
        }, ptime);
    };
}

// The runner drives the generator to completion
function run(generatorFunction) {
    var it = generatorFunction();

    function step(value) {
        var result = it.next(value);
        if (result.done) return;
        // result.value is the function returned by Timedelay
        result.value(step);
    }

    step();
}

run(Messages);

Tre punkter får dette til at fungere. For det første, Timedelay tager ikke længere et callback direkte; den returnerer en funktion, som løberen kan kalde, og giver kontrollen tilbage, når timeren aktiveres. For det andet, it.next(value) føder det forrige resultat ind i den pausede generator, hvilket er det, der tillader yield at vises på højre side af en opgave. For det tredje stopper løberen, så snart result.done bliver sand, så rekursionen afsluttes naturligt. Dette løbermønster er præcis, hvad biblioteker som co leverede, og det er den mekanisme, der async/await senere absorberet i selve sproget.

Generators vs async/await: Hvilken skal bruges

Generators var standardmåden til at skrive flad asynkron kode før async/await eksisterede, og de to deler den samme underliggende idé om at sætte en funktion på pause midtvejs. Node har understøttet async/await indbygget siden version 7.6, hvilket ændrer anbefalingen for alle, der starter nyt arbejde i dag.

Brug async/await for asynkront flow i ny kode, da det fjerner runneren og gendanner almindelig try and catch. Behold generatorer til det, de kun gør godt: dovent producere værdier, iterere store eller uendelige sekvenser og ethvert tilfælde, hvor forbrugeren bestemmer præcis, hvornår den næste værdi beregnes.

Fælles Generator Fejl og hvordan man retter dem

De fleste generatorproblemer skyldes, at man glemmer, at funktionen er inaktiv, indtil noget kalder next(), eller fra små syntakser, der glider rundt om asterisken. Hvert symptom nedenfor angiver dets årsag og dets løsning.

• Der sker ikke noget, når generatoren kaldes: Et kald af den returnerer en iterator, ikke et resultat. next(), eller giv den videre til en løber.
• Syntaksfejl ved udbytte: asterisken mangler. yield er kun gyldig indenfor en function*.
• Værdien fra next() ankommer udefineret: den første next() opkaldet kan ikke levere en værdi, fordi generatoren ikke har nået en yield endnu. Send data fra det andet opkald og fremefter.
• Uendelig løkke i en runner: result.done bliver aldrig tjekket, så next() bliver ved med at blive kaldt efter slutningen. Returner altid når færdig er sandt.
• Fejl forsvinder lydløst: En afvisning i det asynkrone trin sendes aldrig tilbage til generatoren. Send den videre med it.throw(err) så en "try and catch" skrevet inde i generatoren rent faktisk kan se og håndtere den.

Ofte Stillede Spørgsmål