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

Ebben az oktatóanyagban arról fogunk tanulni Generators és azok különbségei a visszahívásokkal

Mik azok a generátorok?

Generators meglehetősen híresek lettek ben node.js az utóbbi időben, és ez valószínűleg annak köszönhető, hogy mire képesek.

• Generators olyan függvényvégrehajtások, amelyek felfüggeszthetők és egy későbbi időpontban folytathatók.
• Generators akkor hasznosak, ha olyan fogalmakat hajtunk végre, mint például a „lusta végrehajtás”. Ez alapvetően azt jelenti, hogy a végrehajtás felfüggesztésével és tetszés szerinti folytatásával csak akkor tudunk értékeket húzni, amikor szükségünk van rá.

Generators az alábbi 2 kulcsmódszerrel rendelkezik.

1. Hozammódszer – A hozammódszer meghívása egy függvényben leállítja a függvény végrehajtását azon az adott sorban, ahol a hozammódszert meghívják.
2. Következő módszer – Ezt a metódust a főalkalmazásból hívják meg egy hozammódszerrel rendelkező függvény végrehajtásának folytatására. A függvény végrehajtása a következő hozammódszerig vagy a metódus végéig folytatódik.

Nézzünk egy példát a generátorok használatára.

Példánkban egy egyszerű Add függvény lesz, amely 2 számot ad hozzá, de folyamatosan leállítjuk a metódus végrehajtását különböző pontokon, hogy bemutassuk, hogyan használhatók a generátorok.

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

var gen = Add(5);

gen.next();

gen.next(); 

Kód Magyarázat

1. Az első lépés a generátor „funkciójának” meghatározása. Ne feledje, hogy ez úgy történik, hogy egy „*” karaktert ad a függvény kulcsszóhoz. Ezután definiálunk egy Add nevű függvényt, amely egy x paramétert vesz fel.
2. A hozam kulcsszó a generátorokra jellemző. Ez hatékony konstrukcióvá teszi egy funkció szüneteltetését bárminek a közepén. Tehát itt a függvény végrehajtása leáll, amíg meg nem hívjuk a next() függvényt, ami a 4. lépésben fog megtörténni. Ekkor az x értéke 6 lesz, és a függvény végrehajtása leáll.
3. Itt hívjuk meg először a generátor függvényt, és küldjük el az 5-ös értéket az Add függvényünkhöz. Ez az érték az Add függvényünk x paraméterében lesz helyettesítve.
4. Miután meghívtuk a next() függvényt, az Add() függvény folytatja a végrehajtást. Amikor a következő var y= result(null) utasítás végrehajtásra kerül, az Add() függvény végrehajtása ismét leáll.
5. A next() függvény ismételt meghívása után a következő utasítások lefutnak, és az x=5 és y=6 együttes értéke hozzáadódik és visszaadódik.

Visszahívások kontra generátorok

Generators az úgynevezett visszahívási pokol problémájának megoldására szolgálnak. Néha a visszahívási függvények annyira beágyazódnak egy Node.js alkalmazás fejlesztése során, hogy túl bonyolulttá válik a visszahívási funkciók használata.

Itt hasznosak a generátorok. Az egyik leggyakoribb példa erre az időzítő funkciók létrehozása.

Nézzük meg az alábbi példát, hogyan bizonyulhatnak hasznosnak a generátorok a visszahívásoknál.

Példánk csak egy egyszerű késleltetési függvényt hoz létre. Ezt a függvényt 1000, 2000 és 3000 ms-os késleltetéssel együtt szeretnénk hívni.

Step 1) Határozza meg visszahívási funkciónkat a szükséges késleltetési kóddal.

function Timedelay(ptime, callback) {

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

Kód Magyarázat

1. Itt létrehozunk egy Timedelay nevű függvényt a ptime nevű paraméterrel. Ez eltartja azt a szükséges késleltetést, amelyet az alkalmazásunkban be szeretnénk vezetni.
2. A következő lépés egy üzenet létrehozása, amely megjelenik a felhasználó számára, és azt mondja, hogy az alkalmazás szünetelteti ezt a sok ezredmásodpercet.

Step 2) Most nézzük meg a kódot, ha beépítettünk visszahívásokat. Tegyük fel, hogy 1000, 2000 és 3000 ezredmásodperc értéken alapuló visszahívásokat szeretnénk beépíteni, az alábbi kód megmutatja, hogyan kellene ezeket visszahívásokkal megvalósítanunk.

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

Kód Magyarázat

1. A Timedelay-t hívjuk visszahívásnak, 1000 értékkel.
2. Ezután újra meg akarjuk hívni a Timedelay függvényt 2000 értékkel.
3. Végül újra meg akarjuk hívni a Timedelay függvényt 3000 értékkel.

A fenti kódból láthatja, hogy ez egyre zavarosabbá válik, mivel szeretnénk többször elindítani a függvény meghívását.

Step 3) Most nézzük meg, hogyan valósítsuk meg ugyanazt a kódot generátorok segítségével. Az alábbi kódból most már láthatja, milyen egyszerűvé vált a Timedelay funkció megvalósítása generátorok segítségével.

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

Kód Magyarázat

1. Először definiálunk egy generátor függvényt, amelyet az Időkésleltetés függvényünk hívására használunk.
2. Meghívjuk a Hozam függvényt a Timedelay függvénnyel együtt, ahol 1000 a paraméterérték.
3. Ezután meghívjuk a hozam függvényt a Timedelay függvénnyel együtt, 2000 paraméterértékkel.
4. Végül meghívjuk a Hozam függvényt a Timedelay függvénnyel együtt, 3000 paraméterértékkel.

Összegzésként

Generators arra is használható, hogy enyhítse a beágyazott visszahívásokkal kapcsolatos problémákat, és segítsen az úgynevezett visszahívási pokol eltávolításában. Generators egy függvény feldolgozásának leállítására szolgál. Ez az aszinkron függvényben a 'hozam' módszer használatával érhető el.