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 Deklaration async function* erstellt eine Bindung einer neuen asynchronen Generatorfunktion zu einem gegebenen Namen.

Sie können auch asynchrone Generatorfunktionen 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

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

Hinweis: Asynchrone Generatorfunktionen haben keine Gegenstücke zu Pfeilfunktionen.

Hinweis: function und * sind separate Token und können daher durch Leerzeichen oder Zeilenumbrüche getrennt sein. Es darf jedoch kein Zeilenumbruch zwischen async und function sein, da sonst ein Semikolon automatisch eingefügt wird, was dazu führt, dass async zu einem Bezeichner wird und der Rest zu einer function* Deklaration.

Parameter

name

Der Funktionsname.

param Optional

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

statements Optional

Die Anweisungen, die den Funktionskörper ausmachen.

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

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

Wenn ein Promise aus einem asynchronen Generator zurückgegeben wird (yield), entspricht der eventualle Zustand des Iterationsresultat-Promises dem des zurückgegebenen Promises. Zum Beispiel:

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

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

1 wird geloggt, weil, wenn das zurückgegebene Promise fehlschlägt, auch das Iterationsresultat fehlschlägt. Die value-Eigenschaft des gelösten Ergebnisses eines asynchronen Generators wird kein weiteres Promise sein.

async function* Deklarationen verhalten sich ähnlich wie function Deklarationen — sie werden gehoistet an den Anfang ihres Gültigkeitsbereichs und können überall in ihrem Bereich aufgerufen werden. Sie können jedoch nur in bestimmten Kontexten erneut deklariert werden.

Beispiele

Deklaration einer asynchronen Generatorfunktion

Asynchrone Generatorfunktionen erzeugen immer Promise-Ergebnisse – selbst wenn jeder yield-Schritt synchron ist.

js
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();
  });

Verwendung einer asynchronen Generatorfunktion, um eine Reihe von Dateien zu lesen

In diesem Beispiel lesen wir eine Reihe von Dateien und greifen nur auf deren Inhalt zu, wenn dies erforderlich ist, unter Verwendung des Moduls fs/promises von NodeJS.

js
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

Browser-Kompatibilität

Report problems with this compatibility data on GitHub
desktopmobileserver
Chrome
Edge
Firefox
Opera
Safari
Chrome Android
Firefox for Android
Opera Android
Safari on iOS
Samsung Internet
WebView Android
WebView on iOS
Deno
Node.js
async function* statement

Legend

Tip: you can click/tap on a cell for more information.

Full support
Full support

Siehe auch