Detaillierte Erklärung asynchroner Iteratoren in nodejs

asyncIterable = [1, 2, 3];
asyncIterable[Symbol.asyncIterator] = asynchrone Funktion*() {
  für (lass i = 0; i < asyncIterable.length; i++) {
    Ertrag { Wert: asyncIterable[i], fertig: false }
  }
  Ertrag { erledigt: wahr };
};

(asynchrone Funktion() {
  für await (const Teil von asyncIterable) {
    konsole.log(Teil);
  }
})();

asynchrone Funktion printFileToConsole(Pfad) {
  versuchen {
    const readStream = fs.createReadStream(Pfad, { Kodierung: 'utf-8' });

    für warten (const chunk of readStream) {
      Konsole.log(Block);
    }

    console.log('EOF');
  } fange(Fehler) {
    konsole.log(Fehler);
  }
}

const https = erfordern('https');

Funktion homebrewFetch(URL) {
  returniere neues Promise(async (auflösen, ablehnen) => {
    const req = https.get(url, async-Funktion(res) {
      wenn (res.statusCode >= 400) {
        Rückgabe ablehnen (neuer Fehler („HTTP-Status: ${res.statusCode}“));
      }

      versuchen {
        lass body = '';

        /*
          Anstatt res.on auf Daten im Stream zu warten,
          Wir können for-await-of verwenden und den Datenblock anhängen
          zum Rest des Antworttexts*/
        für warten (const chunk of res) {
          Körper += Block;
        }
    
        // Behandeln Sie den Fall, dass kein Textkörper vorhanden ist, wenn (!body) resolve({});
        // Wir müssen den Text analysieren, um das JSON zu erhalten, da es sich um einen String handelt. const result = JSON.parse(body);
        Lösung (Ergebnis);
      } fange(Fehler) {
        ablehnen(Fehler)
      }
    });

    warte auf Anforderung;
    erforderlich.ende();
  });
}

Funktion fetchCatPics({ Limit, Seite, fertig }) {
  returniere homebrewFetch(`https://api.thecatapi.com/v1/images/search?limit=${limit}&page=${page}&order=DESC`)
    .then(body => ({ value: body, fertig }));
}

Funktion catPics({ Limit }) {
  zurückkehren {
    [Symbol.asyncIterator]: asynchrone Funktion*() {
      lass aktuelleSeite = 0;
      // Nach 5 Seiten stoppen
      während(aktuelleSeite < 5) {
        versuchen {
          const cats = warte auf fetchCatPics({ aktuelleSeite, limit, fertig: false });
          console.log(`${limit} Katzen abgerufen`);
          Katzen ausbeuten;
          aktuelleSeite++;
        } fange(Fehler) {
          console.log('Beim Abrufen aller Katzen ist ein Fehler aufgetreten!');
          konsole.log(Fehler);
        }
      }
    }
  };
}

(asynchrone Funktion() {
  versuchen {
    für await (let catPicPage of catPics({ limit: 10 })) {
      Konsole.log(catPicPage);
      // Warten Sie 7 Sekunden zwischen den Anfragen
      warte auf neues Promise(resolve => setTimeout(resolve, 7000));
    }
  } fange(Fehler) {
    konsole.log(Fehler);
  }
})()

Funktion tatsächlicheKatzenbilder({ Grenze }) {
  zurückkehren {
    [Symbol.asyncIterator]: () => {
      lass Seite = 0;
      zurückkehren {
        weiter: Funktion() {
          Seite++;
          returniere fetchCatPics({Seite, Limit, fertig: false});
        },
        vorherige: function() {
          if (Seite > 0) {
            Seite--;
            returniere fetchCatPics({Seite, Limit, fertig: false});
          }
          returniere fetchCatPics({Seite: 0, Limit, fertig: true});
        }
      }
    }
  };
}

versuchen {
    const einigeKatzenbilder = tatsächlicheKatzenbilder({ limit: 5 });
    const { nächstes, vorheriges } = einigeKatzenbilder[Symbol.asyncIterator]();
    weiter().dann(console.log);
    weiter().dann(Konsole.log);
    vorherige().dann(Konsole.log);
} fange(Fehler) {
  konsole.log(Fehler);
}