for await...of
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 for await...of-Anweisung erstellt eine Schleife, die über asynchron iterierbare Objekte sowie synchron iterierbare Objekte iteriert. Diese Anweisung kann nur in Kontexten verwendet werden, in denen await zulässig ist, etwa innerhalb des Funktionskörpers einer asynchronen Funktion oder in einem Modul.
Probieren Sie es aus
async function* foo() {
yield 1;
yield 2;
}
(async () => {
for await (const num of foo()) {
console.log(num);
// Expected output: 1
break; // Closes iterator, triggers return
}
})();
Syntax
for await (variable of iterable)
statement
variable-
Erhält bei jeder Iteration einen Wert aus der Sequenz. Kann entweder eine Deklaration mit
const,letodervarsein oder ein Ziel für eine Zuweisung (z. B. eine zuvor deklarierte Variable, eine Objekteigenschaft oder ein Destrukturierungsmuster). Mitvardeklarierte Variablen sind nicht auf die Schleife beschränkt, sondern befinden sich im selben Gültigkeitsbereich wie diefor await...of-Schleife. iterable-
Ein asynchron oder synchron iterierbares Objekt. Es liefert die Sequenz von Werten, über die die Schleife iteriert.
statement-
Eine Anweisung, die bei jeder Iteration ausgeführt wird. Sie kann auf
variableverweisen. Mit einer Blockanweisung können Sie mehrere Anweisungen ausführen.
Beschreibung
Wenn eine for await...of-Schleife über ein iterierbares Objekt iteriert, ruft sie zunächst dessen Methode [Symbol.asyncIterator]() ab und führt sie aus. Diese gibt einen asynchronen Iterator zurück. Wenn die Methode @asyncIterator nicht existiert, sucht die Schleife nach einer Methode [Symbol.iterator](), die einen synchronen Iterator zurückgibt. Der zurückgegebene synchrone Iterator wird anschließend in einen asynchronen Iterator umgewandelt: Jedes von den Methoden next(), return() und throw() zurückgegebene Objekt wird in ein erfülltes oder abgelehntes Promise verpackt. Ist die Eigenschaft value ebenfalls ein Promise, wird sie aufgelöst. Die Schleife ruft dann wiederholt die Methode next() des resultierenden asynchronen Iterators auf und wartet auf das zurückgegebene Promise. So entsteht die Sequenz von Werten, die variable zugewiesen werden.
Eine for await...of-Schleife endet, wenn der Iterator abgeschlossen ist (das Ergebnis von next(), auf das gewartet wurde, ist ein Objekt mit done: true). Wie bei anderen Schleifenanweisungen können Sie innerhalb von statement Anweisungen zur Steuerung des Kontrollflusses verwenden:
breakbeendet die Ausführung vonstatementund setzt die Ausführung mit der ersten Anweisung nach der Schleife fort.continuebeendet die Ausführung vonstatementund setzt die Schleife mit der nächsten Iteration fort.
Wenn die for await...of-Schleife vorzeitig verlassen wird (z. B. weil eine break-Anweisung erreicht oder ein Fehler ausgelöst wird), wird die Methode return() des Iterators aufgerufen, um Aufräumarbeiten durchzuführen. Die Schleife wartet auf das zurückgegebene Promise, bevor sie endet.
for await...of funktioniert im Allgemeinen genauso wie die for...of-Schleife und weist weitgehend dieselbe Syntax und Semantik auf. Es gibt jedoch einige Unterschiede:
for await...offunktioniert sowohl mit synchron als auch mit asynchron iterierbaren Objekten, währendfor...ofnur mit synchron iterierbaren Objekten funktioniert.for await...ofkann nur in Kontexten verwendet werden, in denenawaitzulässig ist, etwa innerhalb des Funktionskörpers einer asynchronen Funktion oder in einem Modul. Auch bei einem synchron iterierbaren Objekt wartet die Schleife bei jeder Iteration auf den zurückgegebenen Wert. Das wiederholte Auspacken von Promises verlangsamt die Ausführung.- Wenn
iterableein synchron iterierbares Objekt ist, das Promises liefert, erzeugtfor await...ofeine Sequenz aufgelöster Werte, währendfor...ofeine Sequenz von Promises erzeugt. - Bei
for await...ofkannvariableder Bezeichnerasyncsein (z. B.for await (async of foo)); beifor...ofist dies nicht zulässig.
Wie bei for...of darf die Variable bei Verwendung einer using-Deklaration nicht of heißen:
for await (using of of []); // SyntaxError
Dadurch wird eine syntaktische Mehrdeutigkeit mit dem Code for await (using of []) vermieden, der vor der Einführung von using gültig war.
Beispiele
>Über asynchron iterierbare Objekte iterieren
Sie können auch über ein Objekt iterieren, das das Protokoll für asynchron iterierbare Objekte ausdrücklich implementiert:
const LIMIT = 3;
const asyncIterable = {
[Symbol.asyncIterator]() {
let i = 0;
return {
next() {
const done = i === LIMIT;
const value = done ? undefined : i++;
return Promise.resolve({ value, done });
},
return() {
// This will be reached if the consumer called 'break' or 'return' early in the loop.
return { done: true };
},
};
},
};
(async () => {
for await (const num of asyncIterable) {
console.log(num);
}
})();
// 0
// 1
// 2
Über asynchrone Generatoren iterieren
Da die Rückgabewerte asynchroner Generatorfunktionen dem Protokoll für asynchron iterierbare Objekte entsprechen, können Sie mit for await...of über sie iterieren.
async function* asyncGenerator() {
let i = 0;
while (i < 3) {
yield i++;
}
}
(async () => {
for await (const num of asyncGenerator()) {
console.log(num);
}
})();
// 0
// 1
// 2
Ein konkreteres Beispiel für die Iteration über einen asynchronen Generator mit for await...of ist die Verarbeitung von Daten aus einer API.
In diesem Beispiel wird zunächst ein asynchron iterierbares Objekt für einen Datenstrom erstellt. Anschließend wird damit die Größe der API-Antwort ermittelt.
async function* streamAsyncIterable(stream) {
const reader = stream.getReader();
try {
while (true) {
const { done, value } = await reader.read();
if (done) return;
yield value;
}
} finally {
reader.releaseLock();
}
}
// Fetches data from URL and calculates response size using the async generator.
async function getResponseSize(url) {
const response = await fetch(url);
// Will hold the size of the response, in bytes.
let responseSize = 0;
// The for-await-of loop. Async iterates over each portion of the response.
for await (const chunk of streamAsyncIterable(response.body)) {
// Incrementing the total response length.
responseSize += chunk.length;
}
console.log(`Response Size: ${responseSize} bytes`); // "Response Size: 1071472"
return responseSize;
}
getResponseSize("https://jsonplaceholder.typicode.com/photos");
Über synchron iterierbare Objekte und Generatoren iterieren
Die for await...of-Schleife kann auch synchron iterierbare Objekte und Generatoren verarbeiten. In diesem Fall wartet sie intern auf die ausgegebenen Werte, bevor sie diese der Schleifenvariablen zuweist.
function* generator() {
yield 0;
yield 1;
yield Promise.resolve(2);
yield Promise.resolve(3);
yield 4;
}
(async () => {
for await (const num of generator()) {
console.log(num);
}
})();
// 0
// 1
// 2
// 3
// 4
// compare with for-of loop:
for (const numOrPromise of generator()) {
console.log(numOrPromise);
}
// 0
// 1
// Promise { 2 }
// Promise { 3 }
// 4
Wenn ein synchroner Generator ein abgelehntes Promise liefert, ruft for await...of die Methode return() des Generators auf, bevor der Ablehnungsgrund als Fehler ausgelöst wird. Dadurch können finally-Blöcke innerhalb des Generators ausgeführt werden.
function* generatorWithRejectedPromises() {
try {
yield 0;
yield 1;
yield Promise.resolve(2);
yield Promise.reject(new Error("failed"));
yield 4;
throw new Error("throws");
} finally {
console.log("called finally");
}
}
(async () => {
try {
for await (const num of generatorWithRejectedPromises()) {
console.log(num);
}
} catch (e) {
console.log("caught", e);
}
})();
// 0
// 1
// 2
// called finally
// caught Error: failed
Spezifikationen
| Spezifikation |
|---|
| ECMAScript® 2027 Language Specification> # sec-for-in-and-for-of-statements> |