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
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:
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.
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.
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 GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
async function* statement |
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support