Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.

View in English Always switch to English

async function*

Baseline
Weitgehend verfügbar

Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Januar 2020 browserübergreifend verfügbar.

Die async function*-Deklaration erstellt eine Bindung einer neuen asynchronen Generatorfunktion an einen bestimmten Namen.

Sie können asynchrone Generatorfunktionen auch mit einem 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 += 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: Für asynchrone Generatorfunktionen gibt es keine entsprechenden Arrow Functions.

Hinweis: function und * sind getrennte Tokens und können daher durch Leerraum oder Zeilenumbrüche voneinander getrennt sein. Zwischen async und function darf jedoch kein Zeilenumbruch stehen. Andernfalls wird automatisch ein Semikolon eingefügt, sodass async zu einem Bezeichner und der Rest zu einer function*-Deklaration wird.

Parameter

name

Der Name der Funktion.

param Optional

Der Name eines formalen Parameters der Funktion. Informationen zur Syntax der Parameter finden Sie in der Referenz zu Funktionen.

statements Optional

Die Anweisungen, aus denen der Funktionskörper besteht.

Beschreibung

Eine async function*-Deklaration erstellt ein AsyncGeneratorFunction-Objekt. Bei jedem Aufruf einer asynchronen Generatorfunktion gibt sie ein neues AsyncGenerator-Objekt zurück, das dem Protokoll für asynchrone Iteratoren entspricht. Jeder Aufruf von next() gibt ein Promise zurück, das mit einem Iterator-Ergebnisobjekt erfüllt wird.

Eine asynchrone Generatorfunktion vereint die Eigenschaften von asynchronen Funktionen und Generatorfunktionen. Im Funktionskörper können Sie sowohl das Schlüsselwort await als auch yield verwenden. Dadurch können Sie asynchrone Aufgaben bequem mit await verarbeiten und zugleich die verzögerte Ausführung von Generatorfunktionen nutzen.

Wenn ein Promise von einem asynchronen Generator mit yield zurückgegeben wird, entspricht der endgültige Zustand des Iterator-Ergebnis-Promise dem Zustand dieses Promise. Zum Beispiel:

js
async function* foo() {
  yield Promise.reject(new Error("failed"));
}

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

Error: failed wird protokolliert, weil auch das Iterator-Ergebnis-Promise abgelehnt wird, wenn das mit yield zurückgegebene Promise abgelehnt wird. Die Eigenschaft value des erfüllten Ergebnisses eines asynchronen Generators enthält kein weiteres Promise.

async function*-Deklarationen verhalten sich ähnlich wie function-Deklarationen: Sie werden an den Anfang ihres Gültigkeitsbereichs vorgezogen und können überall darin aufgerufen werden. Eine erneute Deklaration ist nur in bestimmten Kontexten möglich.

Beispiele

Eine asynchrone Generatorfunktion deklarieren

Asynchrone Generatorfunktionen liefern immer Promises für ihre 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();
  });

Mit einer asynchronen Generatorfunktion eine Reihe von Dateien lesen

In diesem Beispiel lesen wir mithilfe des Node-Moduls fs/promises eine Reihe von Dateien und greifen erst bei Bedarf auf deren Inhalt zu.

js
import fs from "node:fs/promises";
import path from "node:path";

async function* readFiles(directory) {
  const files = await fs.readdir(directory);
  for (const file of files) {
    const fullPath = path.join(directory, file);
    const stats = await fs.stat(fullPath);
    if (stats.isFile()) {
      yield {
        name: file,
        content: await fs.readFile(fullPath, "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

Spezifikation
ECMAScript® 2027 Language Specification
# sec-async-generator-function-definitions

Browser-Kompatibilität

Siehe auch