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.

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.
- 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
yieldMegjelenik. - 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.
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
- Az első lépés a generátorfüggvény definiálása. Figyeljük meg a következőt:
*hozzáadva afunctionkulcsszó. A függvény neveAddés paramétert vesz felx. - Az
yieldkulcsszó generátorokra jellemző, és végrehajtás közben szünetelteti a függvényt. A végrehajtás itt leáll, amígnext()meg van hívva. - A második
yieldmind a függvényt szünetelteti, mind pedig értéket kap: bármit is adunk át a következőneknext()a hívás a következő értékévé válik:y. - Hívás
gen.next()első alkalommal a függvény az elsőig futyieldHívásgen.next(6)folytatja, 6-ot rendel hozzáy, és visszatérx + 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.
function Timedelay(ptime, callback) { setTimeout(function() { callback("Pausing for " + ptime); }, ptime); // the delay must use ptime, the parameter name }
Code Magyarázat
- Egy függvény, amelyet úgy hívnak
Timedelayparaméterrel jön létreptime, amely a szüneteltetéshez szükséges milliszekundumok számát tartalmazza. setTimeoutennyi 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.
Timedelay(1000, function(message) { console.log(message); Timedelay(2000, function(message) { console.log(message); Timedelay(3000, function(message) { console.log(message); }); }); });
Code Magyarázat
Timedelayvisszahívásként hívjuk meg, amelynek értéke 1000.- A visszahíváson belül,
Timedelayismét 2000-rel hívják. - Abban a belsejében,
Timedelayharmadszorra 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.
function* Messages() { console.log(yield Timedelay(1000)); console.log(yield Timedelay(2000)); console.log(yield Timedelay(3000)); }
Code Magyarázat
- Egy generátorfüggvényt definiálunk a meghíváshoz
Timedelayfunkciót. yieldegyütt használjákTimedelayés 1000 a paraméter értéke.yieldismé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.
yieldcsak egy belül érvényesfunction*. - 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 ayieldmég. Küldje el az adatokat a második hívástól kezdve. - Végtelen ciklus egy futóban:
result.donesoha nem ellenőrzik, ezértnext()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.




