Miért engednek meg a szokásos generátorok aszinkron…

A JavaScriptben lévő szokásos generátorok lehetővé teszik az aszinkron kód írását azáltal, hogy képesek szüneteltetni és újraindítani a végrehajtást, valamint értékeket továbbítani mindkét irányba (yield és next()).

Íme, hogyan működik ez az aszinkronitás kontextusában:

Végrehajtás szüneteltetése (yield): Amikor eléri a yield utasítást, a generátor szünetel és visszaad egy értéket. Az aszinkron kódban ez az érték lehet egy promise vagy más "művelet", amit aszinkron módon kell végrehajtani.
Aszinkron eredmény várása: A külső kód (pl. egy "futó" vagy a generátor köré csomagolt kód) megkapja a yield-en keresztül átadott értéket. Ha ez egy promise, akkor várja annak megoldását vagy elutasítását.
Végrehajtás folytatása (next()): Az aszinkron művelet (a promise megoldása) befejeződik, az eredmény (a promise értéke) visszakerül a generátorba a next() metóduson keresztül. A generátor folytatja a végrehajtást attól a ponttól, ahol abbamaradt.
Eredmény átadása: A next()-nek átadott érték lesz a yield kifejezés eredménye a generátorban. Így a generátor "kaphat" eredményt egy aszinkron műveletből, és folytathatja a munkát vele, mintha szinkron kód lenne.

Ez a minta illúziót kelt a szinkron végrehajtási folyamatról az aszinkron műveletek esetében, és olvashatóbbá, kezelhetőbbé teszi a kódot a hagyományos callback-ek vagy összetett .then() láncok helyett.

Egy példa erre a co típusú csomagolás (bár manapság inkább az async/await elterjedt, amelyek lényegében szintaktikus cukorként működnek a generátorok és promise-ok felett):

// Generátor használata aszinkronitáshoz
function* myAsyncGenerator() {
  try {
    const result1 = yield Promise.resolve(1); // Szünet, promise visszaadása
    console.log('Az első eredményt kaptuk:', result1); // Folytatás eredmény átadásával

    const result2 = yield new Promise(resolve => setTimeout(() => resolve(2), 500)); // Még egy aszinkron művelet
    console.log('A második eredményt kaptuk:', result2);

    return 'Kész'; // A generátor befejezése
  } catch (error) {
    console.error('Hiba történt:', error);
  }
}

// Egyszerű "futó" a generátorhoz (egyszerűsített)
function run(generatorFunc) {
  const generator = generatorFunc();

  function handleNext(newValue) {
    const result = generator.next(newValue);

    if (!result.done) {
      if (result.value instanceof Promise) {
        result.value.then(handleNext).catch(handleError);
      } else {
        handleNext(result.value);
      }
    } else {
      console.log('A generátor befejeződött eredménnyel:', result.value);
    }
  }

  function handleError(error) {
      generator.throw(error);
  }

  handleNext(); // A generátor indítása
}

// Indítjuk az aszinkron generátort
run(myAsyncGenerator);

Ebben a példában a yield Promise.resolve(1) szünetelteti a generátort. A "futó" (vagy co) vár, amíg a promise megoldódik, majd újraindítja a generátort, átadva az értéket next(1). Ez az érték 1 lesz a yield Promise.resolve(1) eredménye a generátorban, lehetővé téve, hogy az a következő sorban (console.log) feldolgozásra kerüljön. Ez a mechanizmus lehetővé teszi a szinkron végrehajtási folyamat illúzióját aszinkron műveletek esetén.

Miért engednek meg a szokásos generátorok aszinkron kód írását?