async function*

name

Der Funktionsname.

param Optional

Der Name eines formalen Parameters für die Funktion. Für die Syntax der Parameter siehe die Referenz zu Funktionen.

statements Optional

Die Anweisungen, die den Körper der Funktion bilden.

Eine async function* Deklaration erstellt ein AsyncGeneratorFunction Objekt. Jedes Mal, wenn eine asynchrone Generatorfunktion aufgerufen wird, gibt sie ein neues AsyncGenerator Objekt zurück, das dem asynchronen Iterator-Protokoll entspricht. Jeder Aufruf von next() gibt ein Promise zurück, das sich zum Iterator-Ergebnisobjekt auflöst.

Eine asynchrone Generatorfunktion kombiniert die Eigenschaften von asynchronen Funktionen und Generatorfunktionen. Sie können sowohl die Schlüsselwörter await als auch yield innerhalb des Funktionskörpers verwenden. Dies ermöglicht es Ihnen, asynchrone Aufgaben ergonomisch mit await zu bearbeiten, während Sie die träge Natur von Generatorfunktionen nutzen.

Wenn ein Promise von einem asynchronen Generator geliefert wird, wird der letztendliche Zustand des Iterator-Ergebnis-Promises dem des gelieferten Promises entsprechen. Zum Beispiel:

async function* foo() {
  yield Promise.reject(1);
}

foo()
  .next()
  .catch((e) => console.error(e));

1 wird protokolliert, da, wenn das gelieferte Promise abgelehnt wird, auch das Iterator-Ergebnis abgelehnt wird. Die value-Eigenschaft des aufgelösten Ergebnisses eines asynchronen Generators wird kein weiteres Promise sein.

async function* Deklarationen verhalten sich ähnlich wie function Deklarationen — sie werden gehoben an den Anfang ihres Geltungsbereichs und können überall in ihrem Geltungsbereich aufgerufen werden. Sie können nur in bestimmten Kontexten neu deklariert werden.

Asynchrone Generatorfunktionen liefern immer Versprechen von Ergebnissen — selbst wenn jeder yield-Schritt synchron ist.

async function* myGenerator(step) {
  await new Promise((resolve) => setTimeout(resolve, 10));
  yield 0;
  yield step;
  yield step * 2;
}

const gen = myGenerator(2);
gen
  .next()
  .then((res) => {
    console.log(res); // { value: 0, done: false }
    return gen.next();
  })
  .then((res) => {
    console.log(res); // { value: 2, done: false }
    return gen.next();
  })
  .then((res) => {
    console.log(res); // { value: 4, done: false }
    return gen.next();
  })
  .then((res) => {
    console.log(res); // { value: undefined, done: true }
    return gen.next();
  });

In diesem Beispiel lesen wir eine Serie von Dateien und greifen nur dann auf den Inhalt zu, wenn er angefordert wird, unter Verwendung des fs/promises Moduls von Node.

async function* readFiles(directory) {
  const files = await fs.readdir(directory);
  for (const file of files) {
    const stats = await fs.stat(file);
    if (stats.isFile()) {
      yield {
        name: file,
        content: await fs.readFile(file, "utf8"),
      };
    }
  }
}

const files = readFiles(".");
console.log((await files.next()).value);
// Possible output: { name: 'file1.txt', content: '...' }
console.log((await files.next()).value);
// Possible output: { name: 'file2.txt', content: '...' }

• Leitfaden zu Funktionen
• Leitfaden zu Iteratoren und Generatoren
• Funktionen
• AsyncGeneratorFunction
• async function* Ausdruck
• function
• function*
• async function
• Iterationsprotokolle
• yield
• yield*
• AsyncGenerator