node.js Generators & Hasonlítsa össze a visszahívásokkal

⚡ Okos összefoglaló

GeneratorA Node.js-ben található s függvények olyan függvények, amelyek végrehajtása igény szerint felfüggeszthető és folytatható. A yield kulcsszó szünetelteti a függvényt, a next metódus folytatja azt, és ez a párosítás a mélyen beágyazott visszahívásokat olvasható szekvenciális kóddá lapítja.

  • ⏸️ Alapvető viselkedés: A generátor minden hozamnál felfüggeszti a működését, és pontosan onnan folytatja, ahol leállt, amikor a következőt hívják.
  • ✳️ Nyilatkozat: A function kulcsszó utáni csillag a függvényt generátorként, és nem egy szokványos függvényként jelöli.
  • 🔄 Kétirányú csatorna: A next függvénynek átadott érték lesz a függvényt szüneteltető yield kifejezés eredménye.
  • 🪆 Visszahívási pokol: A beágyazott visszahívások olvashatatlanná válnak a lépések hozzáadásával, és ennek a problémagenerátornak a megoldására alkalmazták őket.
  • 🏃 Futó szükséges: Egy generátor nem hajtja meg önmagát; egy runner függvénynek ismételten meg kell hívnia a next függvényt az aszinkron munka folytatásához.
  • 🦥 Lusta végrehajtás: A felfüggesztés és folytatás lehetővé teszi a program számára, hogy csak akkor kérjen le értékeket, amikor szükség van rájuk.

node.js GeneratorÖsszehasonlítva a visszahívásokkal

Ebben az útmutatóban a generátorokat vizsgáljuk meg, és azt, hogy miben különböznek a visszahívásoktól.

Mik azok a generátorok?

Generatornépszerűvé vált node.js amiatt, amire képesek.

  • Generators olyan függvényvégrehajtások, amelyek felfüggeszthetők és egy későbbi időpontban folytathatók.
  • GeneratorAz s függvények olyan fogalmak esetén hasznosak, mint a „lusta végrehajtás”. A végrehajtás felfüggesztésével és tetszőleges folytatásával az értékek csak akkor kerülnek lekérésre, amikor szükség van rájuk.

Generatoraz alábbi két fő módszerrel rendelkeznek.

  1. Hozammódszer — egy függvényen belül hívható meg a végrehajtás leállításához pontosan annál a sorban, ahol yield Megjelenik.
  2. Következő módszer — a fő alkalmazásból hívják meg egy olyan függvény folytatásához, amelyik már nem fut le. A végrehajtás a következőig folytatódik yield, vagy a függvény végéig.

Nézzünk egy példát a generátorok használatára. A példa egy egyszerű Add függvényt definiál, amely két számot összead, és a végrehajtását különböző pontokon leállítja, hogy bemutassa a generátorok viselkedését.

node.js Generators

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 Magyarázat

  1. Az első lépés a generátorfüggvény definiálása. Figyeljük meg a következőt: * hozzáadva a function kulcsszó. A függvény neve Add és paramétert vesz fel x.
  2. Az yield kulcsszó generátorokra jellemző, és végrehajtás közben szünetelteti a függvényt. A végrehajtás itt leáll, amíg next() meg van hívva.
  3. A második yield mind a függvényt szünetelteti, mind pedig értéket kap: bármit is adunk át a következőnek next() a hívás a következő értékévé válik: y.
  4. Hívás gen.next() első alkalommal a függvény az elsőig fut yieldHívás gen.next(6) folytatja, 6-ot rendel hozzá y, és visszatér x + y.

⚠️ Javítás: az eredeti lista tartalmazta a sort y = 6 azonnal után var y = yield(null);Ez az értékadás felülír bármilyen értéket. next() kellékek, ami meghiúsítja a példa célját, és a másodikat yield értelmetlen. Az érték most átkerül a gen.next(6), amelyen keresztül a generátor valójában adatokat fogad a hívótól.

Visszahívások vs. generátorok

Generatormegoldják a visszahívási pokolként ismert problémát. A visszahívási függvények néha annyira mélyen beágyazódnak egy Node.js alkalmazás fejlesztése során, hogy nehéz követni őket.

Itt segítenek a generátorok. Az egyik leggyakoribb példa az időzítő függvények létrehozása. Az alábbi példa egy egyszerű időkésleltetési függvényt hoz létre, majd 1000, 2000 és 3000 ms késleltetéssel hívja meg.

Step 1) Definiálja a visszahívó függvényt a szükséges időkésleltetési kóddal.

Visszahívások vs. Generators

function Timedelay(ptime, callback) {

    setTimeout(function() {

        callback("Pausing for " + ptime);

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

Code Magyarázat

  1. Egy függvény, amelyet úgy hívnak Timedelay paraméterrel jön létre ptime, amely a szüneteltetéshez szükséges milliszekundumok számát tartalmazza.
  2. setTimeout ennyi milliszekundumot vár, majd meghívja a megadott visszahívást.

⚠️ Javítás: az eredeti kód átment time második érvként setTimeout, de nincs elnevezett változó time létezik — a paraméter ptimeAhogy meg van írva, dob ReferenceError: time is not defined.

Step 2) Most vizsgáljuk meg a visszahívásokat használó kódot. Az 1000, 2000 és 3000 milliszekundumos késleltetések láncolásához a visszahívások egymásba ágyazódnak.

Visszahívások vs. Generators

Timedelay(1000, function(message) {

    console.log(message);

    Timedelay(2000, function(message) {

        console.log(message);

        Timedelay(3000, function(message) {

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

Code Magyarázat

  1. Timedelay visszahívásként hívjuk meg, amelynek értéke 1000.
  2. A visszahíváson belül, Timedelay ismét 2000-rel hívják.
  3. Abban a belsejében, Timedelay harmadszorra is meghívják 3000-rel.

⚠️ Javítás: minden visszahívás az eredeti naplózottban msg, de a paraméter neve messageMindhárom sor dobta ReferenceError: msg is not defined.

A fenti kódból látható, hogy minden további hívásnál egyre kaotikusabbá válik – ezt a beágyazást írja le a callback hell.

Step 3) Most lásd ugyanezt a viselkedést generátorokkal leírva. A sorozat három sík vonalként olvasható le, nem pedig három beágyazási szintként.

Visszahívások vs. Generators

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

Code Magyarázat

  1. Egy generátorfüggvényt definiálunk a meghíváshoz Timedelay funkciót.
  2. yield együtt használják Timedelay és 1000 a paraméter értéke.
  3. yield ismét a 2000-rel, majd még egyszer a 3000-rel használatos.

⚠️ Javítás: az eredeti írta console,log(...) mindhárom sorban vesszővel a pont helyett, ami szintaktikai hiba, és egyáltalán megakadályozza a fájl elemzését.

Hogyan kell futtatni a Generator egy Futó függvénnyel

A fenti generátor szépen olvasható, de önmagában semmit sem csinál. Ez az a részlet, amit a legtöbb magyarázat kihagy, és ez az oka annak, hogy a lapos verzió varázslatosnak tűnhet. A generátor egy szüneteltetett gép, és valaminek folyamatosan nyomva kell tartania a gombot. Hívás Messages() egyszerűen létrehozza a generátor objektumot és azonnal visszaadja az eredményt; soha nem indul el időzítő, és semmi sem kerül kiírásra.

A hiányzó darab egy futó: egy kis függvény, amely meghívja next(), megvárja az aszinkron munka befejezését, majd meghívja a next() ismét az eredménnyel.

// 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);

Három pont teszi ezt működőképessé. Először is, Timedelay már nem fogad közvetlenül visszahívást; egy olyan függvényt ad vissza, amelyet a futtató meghívhat, és visszaadja a vezérlést, amikor az időzítő elindul. Másodszor, it.next(value) az előző eredményt betáplálja a szüneteltetett generátorba, ami lehetővé teszi yield hogy egy feladat jobb oldalán jelenjen meg. Harmadszor, a futó megáll, amint result.done igazzá válik, így a rekurzió természetesen véget ér. Ez a futtatóminta pontosan az, amit a kódtárak, például a co biztosítottak, és ez az a mechanizmus, amely async/await később beépült magába a nyelvbe.

Generators vs. async/await: Melyiket használjuk

Generatoraz s volt a standard módja a lapos aszinkron kód írásának korábban async/await létezett, és a kettő ugyanazon az alapötleten alapul, hogy egy függvényt félbe kell szüneteltetni. A Node támogatta async/await natívan a 7.6-os verzió óta, ami megváltoztatja az ajánlást mindazok számára, akik ma kezdenek új munkát.

Aspect Generators async/wait
Futót keresünk Igen, Ön írta, vagy egy könyvtár írta Nem, a nyelvbe beépítve
Kulcsszó szüneteltetése yield await
Hibakezelés A futónak továbbítania kell a hibákat Szokásos próbálkozás és elkapás
Félúton szüneteltethető Igen, és szelektíven folytatható Nem, a befejezésig tart
A legjobb Lusta szekvenciák és végtelen streamek Szokásos aszinkron munka

Felhasználás async/await az új kód aszinkron folyamához, mivel eltávolítja a futtatót, és visszaállítja a szokásos try and catch függvényeket. A generátorokat csak arra tartsuk meg, amiben jól teljesítenek: értékek lustán történő előállítása, nagy vagy végtelen sorozatok iterálása, és minden olyan eset, amikor a felhasználó dönti el, hogy pontosan mikor számítsa ki a következő értéket.

Közös Generator Hibák és hogyan javítsuk ki őket

A legtöbb generátorral kapcsolatos probléma abból adódik, hogy elfelejtjük, hogy a függvény inert, amíg valami meg nem hívja next(), vagy a csillag körüli apró szintaxisbeli elcsúszásokból. Az alábbi tünetek mindegyike megnevezi az okát és a megoldását.

  • Semmi sem történik, amikor a generátort meghívjuk: A hívás egy iterátort ad vissza, nem eredményt. next(), vagy add át egy futónak.
  • Szintaxishiba a yield-en: a csillag hiányzik. yield csak egy belül érvényes function*.
  • A next() függvényből származó érték definiálatlanul érkezik: Az első next() A hívás nem tud értéket kézbesíteni, mert a generátor még nem érte el a yield még. Küldje el az adatokat a második hívástól kezdve.
  • Végtelen ciklus egy futóban: result.done soha nem ellenőrzik, ezért next() A vége után is meghívódik. Mindig térjen vissza, ha a „done” igaz.
  • A hibák csendben eltűnnek: Az aszinkron lépésen belüli elutasítás soha nem kerül vissza a generátorba. Továbbítsa a következővel: it.throw(err) hogy a generátorba írt try és catch utasítások ténylegesen láthassák és kezelhessék azt.

GYIK

Egy objektum két tulajdonsággal: value, megtartva azt, amit átadtak, és done, egy logikai érték, amely igazzá válik, ha a generátor befejeződik. A futtatóprogramok tesztet végeznek, hogy tudják, mikor kell leállni.

Igen. Egy végtelen ciklust tartalmazó generátor biztonságos, mivel semmi sem számít, amíg a next() függvényt meg nem hívjuk. Emiatt a generátorok jól alkalmasak azonosítók vagy lapozott eredmények folyamaihoz.

Igen. AI az eszközök a yield-et await-ra cserélik, és teljesen elvetik a futót. RevA lusta szekvenciákat óvatosan kell vizsgálni, mert egy soha be nem fejeződő generátornak nincs közvetlen aszinkron várakozási megfelelője.

AI asszisztensek trace hogy a futtató leállította-e a következő hívást, hogy soha nem hívtak-e visszahívást, vagy hogy a művelet soha nem érte-e el a kész állapotot. Ez a három tényező magyarázza szinte az összes leállt generátort.

Nem. Egy aszinkron generátort deklaráltak. async function* és felemészti for await...ofMindkét ötletet ötvözi, és alkalmas aszinkron adatok, például adatbázis-kurzorok streamelésére.

Foglald össze ezt a bejegyzést a következőképpen: