// I1.4 · ca. 33 Min. · Aufbau
Nach dieser Lektion wählen Sie für eine Gruppe von Promises den passenden Kombinator: jedes Ergebnis, jeden Ausgang, den ersten Erfolg oder den ersten, der fertig wird, womit Sie auch ein Timeout bauen.
Danach können Sie
Aufwärmen · Aufgabe 1 von 7
try {
console.log(await Promise.all([fake("a", 20), fake("b", 10, false)]));
} catch (error) {
console.log("caught:", error.message);
}Vorhersagen · Aufgabe 2 von 7
const file = await Promise.any([fake("mirror 1", 30), fake("mirror 2", 10, false), fake("mirror 3", 20)]);
console.log(file);Üben · Aufgabe 3 von 7
const results = await Promise.____([fake("a", 20), fake("b", 10, false)]);
console.log(results.map((r) => r.status + " " + (r.value ?? r.reason.message)).join(", "));Üben · Aufgabe 4 von 7
Üben · Aufgabe 5 von 7
const timeout = (ms) => new Promise((resolve, reject) => setTimeout(() => reject(new Error("timed out")), ms));
try {
console.log(await Promise.race([fake("report", 50), timeout(20)]));
} catch (error) {
console.log("error:", error.message);
}Denksport · Aufgabe 6 von 7
try {
await Promise.any([
Promise.reject(new Error("first")),
Promise.reject(new Error("second"))
]);
} catch (error) {
console.log(error.name, error.errors.length, error.errors[1].message);
}Anwenden · Aufgabe 7 von 7
Prüfen Sie Ihr Ergebnis anhand dieser Liste
Lesen Sie das ausgearbeitete Beispiel und lösen Sie dann die Übungen. Ihr Code läuft in Ihrem Browser oder auf Ihrem Computer und wird nie hochgeladen.
Ausgearbeitetes Beispiel
fake() wird nach einer Verzögerung erledigt, erfüllt mit seinem Namen oder abgelehnt. Jeder Kombinator bekommt eine Gruppe davon. all liefert jeden Wert in der Reihenfolge der Eingabe oder scheitert an b. allSettled meldet beide Ausgänge. any findet den ersten Spiegelserver, der funktioniert, und wirft einen AggregateError, wenn alle ausfallen. race nimmt den Ersten, der erledigt ist, und mit einem Timer, der ablehnt, ist das ein Timeout.
main.js
// fake(name, ms, ok) settles after ms milliseconds: fulfilled with name, or rejected.
const fake = (name, ms, ok = true) =>
new Promise((resolve, reject) =>
setTimeout(() => (ok ? resolve(name) : reject(new Error(`${name} failed`))), ms)
);
console.log("all:", await Promise.all([fake("a", 30), fake("b", 10)]));
try {
await Promise.all([fake("a", 30), fake("b", 10, false)]);
} catch (error) {
console.log("all failed:", error.message);
}
const settled = await Promise.allSettled([fake("a", 30), fake("b", 10, false)]);
console.log("allSettled:", settled.map((r) => r.status));
console.log("any:", await Promise.any([fake("mirror 1", 30), fake("mirror 2", 10, false), fake("mirror 3", 20)]));
try {
await Promise.any([fake("x", 10, false), fake("y", 20, false)]);
} catch (error) {
console.log("any failed:", error.name, error.errors.map((e) => e.message));
}
const timeout = (ms) =>
new Promise((resolve, reject) => setTimeout(() => reject(new Error(`timed out after ${ms} ms`)), ms));
console.log("race:", await Promise.race([fake("quick", 10), timeout(50)]));
try {
await Promise.race([fake("slow", 80), timeout(20)]);
} catch (error) {
console.log("race failed:", error.message);
}
Ausführen mit
node main.jsAusgabe
all: [ 'a', 'b' ]
all failed: b failed
allSettled: [ 'fulfilled', 'rejected' ]
any: mirror 3
any failed: AggregateError [ 'x failed', 'y failed' ]
race: quick
race failed: timed out after 20 msTab rückt ein, Umschalt+Tab rückt aus. Um den Editor mit der Tastatur zu verlassen, drücken Sie Esc und dann Tab.
Beim ersten Ausführen lädt Ihr Browser den JavaScript-Runner herunter (bis zu 0.1 MB) und speichert ihn im Cache. Ihr Code läuft in der eigenen Engine Ihres Browsers und bleibt auf Ihrem Gerät.
Übung 1 von 2
withTimeout(promise, ms) soll so erledigt werden wie promise, wenn es innerhalb von ms Millisekunden erledigt ist, und sonst mit einem Error abgelehnt werden, dessen Meldung timed out after <ms> ms lautet. Der Startcode lässt promise gegen einen Timer antreten, der erfüllt, ein langsames Promise ergibt also undefined statt eines Fehlers. Lassen Sie den Timer ablehnen.
Tab rückt ein, Umschalt+Tab rückt aus. Um den Editor mit der Tastatur zu verlassen, drücken Sie Esc und dann Tab.
Beim ersten Ausführen lädt Ihr Browser den JavaScript-Runner herunter (bis zu 0.1 MB) und speichert ihn im Cache. Ihr Code läuft in der eigenen Engine Ihres Browsers und bleibt auf Ihrem Gerät.
Führen Sie die Tests aus: Der langsame Fall ergibt undefined. Womit wird das Timer-Promise erledigt?
race übernimmt die erste Eingabe, die erledigt wird, erfüllt oder abgelehnt. Der Timer muss ablehnen, damit race ablehnt.
new Promise((resolve, reject) => setTimeout(() => reject(new Error(`timed out after ${ms} ms`)), ms))
Ein möglicher Lösungsweg. Ihrer kann anders aussehen und trotzdem alle Prüfungen bestehen.
export function withTimeout(promise, ms) {
const timer = new Promise((resolve, reject) =>
setTimeout(() => reject(new Error(`timed out after ${ms} ms`)), ms)
);
return Promise.race([promise, timer]);
}
Installieren Sie ECMAScript 2026 oder neuer. Speichern Sie diese Dateien in einem Ordner, öffnen Sie dort ein Terminal und führen Sie die Befehle unten aus.
main.js
export function withTimeout(promise, ms) {
const timer = new Promise((resolve) => setTimeout(resolve, ms));
return Promise.race([promise, timer]);
}
main.test.js
import {test} from 'node:test';
import assert from 'node:assert/strict';
import {withTimeout} from './main.js';
const later = (value, ms) => new Promise((resolve) => setTimeout(() => resolve(value), ms));
test('Ein schnelles Promise liefert seinen Wert', async () => {
const got = await withTimeout(later('report', 5), 50);
assert.equal(got, 'report', `withTimeout gab ${got}`);
});
test('Ein langsames Promise wird mit timed out after 20 ms abgelehnt', async () => {
await assert.rejects(withTimeout(later('report', 60), 20), {message: 'timed out after 20 ms'}, 'withTimeout sollte ablehnen, wenn das Promise zu langsam ist');
});
test('Eine schnelle Ablehnung wird unverändert durchgereicht', async () => {
await assert.rejects(withTimeout(Promise.reject(new Error('offline')), 50), {message: 'offline'}, 'withTimeout sollte mit dem eigenen Fehler des Promise ablehnen');
});
package.json
{
"type": "module"
}
package.json sagt Node.js, dass die .js-Dateien Module sind; lassen Sie die Datei im Ordner.
Programm ausführen:
node main.jsPrüfungen ausführen (learnrun.js muss im selben Ordner liegen):
node --testÜbung 2 von 2
firstAvailable(mirrors) bekommt ein Array von Funktionen; jede startet einen Download und gibt ein Promise zurück. Es soll alle starten und das erste erfolgreiche Ergebnis zurückgeben, auch wenn ein schnellerer Spiegelserver ausfällt. Fallen alle aus, wird es mit einem Error abgelehnt, dessen Meldung no mirror available lautet. Der Startcode benutzt race, ein schneller Fehlschlag gewinnt also. Benutzen Sie den richtigen Kombinator.
Tab rückt ein, Umschalt+Tab rückt aus. Um den Editor mit der Tastatur zu verlassen, drücken Sie Esc und dann Tab.
Beim ersten Ausführen lädt Ihr Browser den JavaScript-Runner herunter (bis zu 0.1 MB) und speichert ihn im Cache. Ihr Code läuft in der eigenen Engine Ihres Browsers und bleibt auf Ihrem Gerät.
Führen Sie die Tests aus: Der ausgefallene Spiegelserver us gewinnt das Rennen. Welcher Kombinator ignoriert Ablehnungen?
Promise.any wird mit dem ersten Erfolg erfüllt und nur abgelehnt, wenn jede Eingabe abgelehnt wurde.
Packen Sie await Promise.any(…) in try/catch und werfen Sie im catch throw new Error("no mirror available").
Ein möglicher Lösungsweg. Ihrer kann anders aussehen und trotzdem alle Prüfungen bestehen.
export async function firstAvailable(mirrors) {
try {
return await Promise.any(mirrors.map((start) => start()));
} catch {
throw new Error("no mirror available");
}
}
Installieren Sie ECMAScript 2026 oder neuer. Speichern Sie diese Dateien in einem Ordner, öffnen Sie dort ein Terminal und führen Sie die Befehle unten aus.
main.js
export async function firstAvailable(mirrors) {
return Promise.race(mirrors.map((start) => start()));
}
main.test.js
import {test} from 'node:test';
import assert from 'node:assert/strict';
import {firstAvailable} from './main.js';
const mirror = (name, ms, ok = true) => () =>
new Promise((resolve, reject) => setTimeout(() => (ok ? resolve(name) : reject(new Error(name + ' down'))), ms));
test('Der schnellste funktionierende Spiegelserver gewinnt', async () => {
const got = await firstAvailable([mirror('eu', 30), mirror('us', 10)]);
assert.equal(got, 'us', `firstAvailable gab ${got}`);
});
test('Ein schnellerer Spiegelserver, der ausfällt, wird übersprungen', async () => {
const got = await firstAvailable([mirror('eu', 30), mirror('us', 5, false)]);
assert.equal(got, 'eu', `firstAvailable gab ${got}`);
});
test('Fallen alle aus, wird mit no mirror available abgelehnt', async () => {
await assert.rejects(firstAvailable([mirror('eu', 10, false), mirror('us', 5, false)]), {message: 'no mirror available'}, 'firstAvailable sollte mit no mirror available ablehnen');
});
package.json
{
"type": "module"
}
package.json sagt Node.js, dass die .js-Dateien Module sind; lassen Sie die Datei im Ordner.
Programm ausführen:
node main.jsPrüfungen ausführen (learnrun.js muss im selben Ordner liegen):
node --testconst a = Promise.resolve("a");
const b = Promise.resolve("b");
const values = await Promise.all(a, b);
console.log(values);
Was Node.js ausgibt
TypeError: object is not iterable (cannot read property Symbol(Symbol.iterator))Warum, und die Lösung
Jeder Kombinator nimmt als einziges Argument ein iterierbares Objekt, meist ein Array. Promise.all(a, b) behandelt das Promise a als dieses iterierbare Objekt und ignoriert b, und ein Promise lässt sich nicht durchlaufen. Setzen Sie die Eingaben in eckige Klammern: await Promise.all([a, b]).
const loadA = async () => "a";
const loadB = async () => "b";
const [first] = await Promise.all([loadA, loadB]);
console.log(first.toUpperCase());
Was Node.js ausgibt
TypeError: first.toUpperCase is not a functionWarum, und die Lösung
Ein Wert im Array, der kein Promise ist, wird unverändert durchgereicht. Hier sind diese Werte die Funktionen selbst, first ist also die Funktion loadA, und es wurde gar nichts geladen. Rufen Sie jede Funktion auf, damit das Array laufende Promises enthält: Promise.all([loadA(), loadB()]).
const down = (name) => Promise.reject(new Error(`${name} down`));
const file = await Promise.any([down("eu"), down("us")]);
console.log(file);
Was Node.js ausgibt
AggregateError: All promises were rejectedWarum, und die Lösung
Wenn jede Eingabe abgelehnt wird, lehnt any mit einem AggregateError ab, und nichts fängt ihn hier ab, das Programm stoppt also. Die Meldung sagt nur, dass alle abgelehnt wurden; die Gründe stehen in error.errors. Warten Sie in try/catch darauf und lesen Sie error.errors, um den Grund jedes Spiegelservers zu sehen.
JavaScript im Browser: die eigene Engine Ihres Browsers in einem abgeschotteten Worker. Syntaxfehler findet acorn 8.18.0, MIT. Lizenz und Quellcode
5 Fragen, ohne Hinweise. Ab 80 % ist die Lektion abgeschlossen.
Erledigen Sie zuerst alle Aufgaben oben, um das Abschlussquiz freizuschalten.