async function*

Baseline Widely available

This feature is well established and works across many devices and browser versions. It’s been available across browsers since January 2020.

Die async function* Deklaration erstellt eine Binding einer neuen asynchronen Generatorfunktion zu einem gegebenen Namen.

Sie können asynchrone Generatorfunktionen auch mit dem async function* Ausdruck definieren.

Probieren Sie es aus

async function* foo() {
  yield await Promise.resolve("a");
  yield await Promise.resolve("b");
  yield await Promise.resolve("c");
}

let str = "";

async function generate() {
  for await (const val of foo()) {
    str = str + val;
  }
  console.log(str);
}

generate();
// Expected output: "abc"

Syntax

async function* name(param0) {
  statements
}
async function* name(param0, param1) {
  statements
}
async function* name(param0, param1, /* …, */ paramN) {
  statements
}

Hinweis: Asynchrone Generatorfunktionen haben keinen Gegenpart in Pfeilfunktionen.

Hinweis: function und * sind separate Tokens, so dass sie durch Leerzeichen oder Zeilentrenner getrennt werden können. Es darf sich jedoch kein Zeilentrenner zwischen async und function befinden, andernfalls wird ein Semikolon automatisch eingefügt, wodurch async zu einem Bezeichner wird und der Rest zu einer function* Deklaration wird.

Parameter

name: Der Funktionsname.
param Optional: Der Name eines formalen Parameters der Funktion. Für die Syntax der Parameter siehe die Funktionsreferenz.
statements Optional: Die Anweisungen, die den Körper der Funktion bilden.

Beschreibung

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 auf das Iterator-Ergebnisobjekt auflöst.

Eine asynchrone Generatorfunktion vereint 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 handhaben, während Sie die Lazy-Natur von Generatorfunktionen nutzen.

Wenn ein Promise von einem asynchronen Generator geliefert wird, wird der endgültige Zustand des Iteratorergebnis-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, weil, wenn das gelieferte Promise abgelehnt wird, das Iteratorergebnis ebenfalls 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 Beginn ihres Gültigkeitsbereichs und können überall in ihrem Gültigkeitsbereich aufgerufen werden, und sie können nur in bestimmten Kontexten neu deklariert werden.

Beispiele

Deklarieren einer asynchronen Generatorfunktion

Asynchrone Generatorfunktionen produzieren immer Promises von Ergebnissen — selbst wenn jeder yield-Schritt synchon 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();
  });

Verwenden einer asynchronen Generatorfunktion zum Lesen einer Reihe von Dateien

In diesem Beispiel lesen wir eine Reihe von Dateien und greifen nur dann auf deren Inhalt zu, wenn dies angefordert wird, unter Verwendung von Nodes fs/promises Modul.

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: '...' }

Spezifikationen

Specification
ECMAScript® 2025 Language Specification # sec-async-generator-function-definitions