Abschnitt 15 · Lektion 4
Promises
Du rufst eine Funktion auf, die einen Artikel lädt, und willst mit dem Ergebnis weitermachen, wann immer es kommt. Einen Fehler willst du dabei an einer einzigen Stelle behandeln. Mit Callbacks heißt das, die Anweisungen mitzugeben, bevor klar ist, ob überhaupt etwas kommt. Ein Promise dreht das um. Die Funktion gibt sofort etwas zurück, nämlich einen Platzhalter für ein Ergebnis, das es noch nicht gibt. Den kannst du weiterreichen, in einer Variablen ablegen und an mehreren Stellen abfragen.
Gut passt der Vergleich mit der Nummer an der Wursttheke. Die bekommst du sofort, und sie ist nicht die Wurst. Sie ist die Zusage, dass du irgendwann drankommst, vielleicht auch mit der Nachricht, dass es aus ist.
Die drei Zustände
Ein Promise ist in genau einem von drei Zuständen.
- pending, also schwebend. So fängt jedes an.
- fulfilled, also erfüllt. Es hat einen Wert.
- rejected, also abgelehnt. Es hat einen Grund, üblicherweise ein
Error-Objekt.
Der Wechsel passiert genau einmal. Ein erfülltes Promise wird nie wieder abgelehnt und ein abgelehntes nie wieder erfüllt. Ein zweiter Aufruf von aufloesen bleibt wirkungslos. Ein Handler läuft also nie zweimal für dasselbe Promise.
then, catch, finally
<p>Zwei Anfragen an dieselbe Funktion, eine geht gut aus.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} const lager = { a1: "Tastatur", b2: "Maus" };
function artikelLaden(id) {
return new Promise((aufloesen, ablehnen) => {
setTimeout(() => {
const name = lager[id];
if (!name) {
ablehnen(new Error(`Nicht im Lager: ${id}`));
return;
}
aufloesen(name);
}, 150);
});
}
artikelLaden("a1")
.then((name) => {
console.log("Gefunden:", name);
})
.catch((fehler) => {
console.error("Ging nicht:", fehler.message);
})
.finally(() => {
console.log("Anfrage 1 ist durch, so oder so.");
});
artikelLaden("zzz")
.then((name) => {
console.log("Gefunden:", name);
})
.catch((fehler) => {
console.error("Ging nicht:", fehler.message);
})
.finally(() => {
console.log("Anfrage 2 ist durch, so oder so.");
});
console.log("Beide Anfragen sind abgeschickt."); An ein Promise hängst du Funktionen, die aufgerufen werden, sobald es so weit ist.
then(fn)läuft, wenn es erfüllt wurde, undfnbekommt den Wert.catch(fn)läuft, wenn es abgelehnt wurde, undfnbekommt den Grund.finally(fn)läuft in beiden Fällen und bekommt nichts, dasselbe Aufräum-Werkzeug wie in Lektion 14.2.
Die drei sehen aus wie try, catch und finally, und das ist volle Absicht. Nur funktionieren sie hier auch dann, wenn zwischen dem Aufruf und dem Ergebnis eine halbe Sekunde liegt.
Im Beispiel steht Beide Anfragen sind abgeschickt. ganz oben in der Console, denn der Code darüber hat nur angemeldet und nicht gewartet.
Verketten
<p>Zweimal dieselbe Kette. In der zweiten fehlt ein return.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} function zahlLaden() {
return Promise.resolve(10);
}
// Mit return gibt jedes then etwas zurück, und das kommt im
// nächsten an.
zahlLaden()
.then((zahl) => {
return zahl * 2;
})
.then((verdoppelt) => {
console.log("mit return:", verdoppelt);
});
// Ohne return rechnet das then zwar, gibt aber nichts zurück.
// Im nächsten kommt deshalb undefined an.
zahlLaden()
.then((zahl) => {
zahl * 2;
})
.then((verdoppelt) => {
console.log("ohne return:", verdoppelt);
}); Jedes then gibt selbst wieder ein Promise zurück, und das unterscheidet Promises von Callbacks. Deshalb lässt sich an ein then direkt das nächste hängen, und was in einem then zurückgegeben wird, kommt im nächsten als Wert an. Aus der Verschachtelung wird eine Liste, die untereinander steht.
Gibt ein then selbst ein Promise zurück, wird darauf gewartet. Das nächste then bekommt dann dessen aufgelösten Wert. So kannst du Schritte aneinanderreihen, die alle Zeit brauchen.
Ärger macht dabei ein vergessenes return. Im zweiten Beispiel steht in der zweiten Kette zahl * 2; ohne return. Gerechnet wird, das Ergebnis fällt auf den Boden, und im nächsten then kommt undefined an. Wenn in einer Kette plötzlich undefined auftaucht, liegt der Grund meistens im then davor.
Mit einer Aufzeichnung im Reiter „Debug“ siehst du beide Ketten untereinander, und der Unterschied ist eine einzige Zeile. In der einen steht verdoppelt=20, in der anderen verdoppelt=undefined. Zwei Schritte davor steht der Grund, einmal return zahl * 2; und einmal zahl * 2;.
Mit einer Arrow Function ohne geschweifte Klammern passiert das nicht. .then((zahl) => zahl * 2) gibt automatisch zurück, und deshalb steht diese Schreibweise in Ketten so oft. Im Protokoll taucht sie dafür gar nicht auf, denn aufgezeichnet werden Anweisungen, und eine Arrow Function ohne Klammern hat keine, sie ist nur ein Ausdruck.
Ein catch für die ganze Kette
<p>Ein catch am Ende reicht für alle Schritte davor.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} function schritt(marke, scheitert) {
return new Promise((aufloesen, ablehnen) => {
setTimeout(() => {
console.log("schritt läuft:", marke);
if (scheitert) {
ablehnen(new Error(`abgebrochen bei ${marke}`));
return;
}
aufloesen(marke);
}, 80);
});
}
schritt("Teig kneten", false)
.then((teig) => schritt("backen", true))
.then((brot) => schritt("abkühlen", false))
.then((fertig) => {
console.log("Alle drei durch:", fertig);
})
.catch((fehler) => {
console.error("Ein catch für alle drei:", fehler.message);
});
// Und hier ohne catch. Die Console meldet das eigens.
schritt("Brötchen holen", true); Wird irgendwo in der Kette abgelehnt, springt die Ausführung über alle folgenden then hinweg zum ersten catch. Ein einziges catch am Ende deckt damit jeden Schritt davor ab, und das ist die zweite große Verbesserung gegenüber Callbacks.
Im dritten Beispiel scheitert der Schritt backen. In der Console erscheint schritt läuft: abkühlen nie, denn der dritte Schritt wird gar nicht erst gestartet.
Nach einem catch geht die Kette übrigens weiter, als wäre nichts gewesen. Ein then hinter dem catch läuft also wieder. Das ist richtig, wenn das catch einen Ersatzwert liefert.
Unbehandelte Ablehnungen
Ganz unten im dritten Beispiel steht ein Aufruf ohne catch. Ein abgelehntes Promise, an dem niemand ein catch hängen hat, wird als unhandled rejection gemeldet. In der Console der Lektion steht dann Unhandled Promise Rejection: Error: abgebrochen bei Brötchen holen, und in den Entwicklerwerkzeugen des Browsers heißt dieselbe Zeile Uncaught (in promise). Gemeint ist beide Male, dass etwas abgelehnt wurde und niemand zugehört hat.
Diese Zeile ist der einzige Hinweis. Das Programm bricht nicht ab, es läuft einfach ohne das Ergebnis weiter, und wenn eine Seite still etwas nicht tut, schaust du am besten zuerst in die Console.
Selbst eines bauen
new Promise((aufloesen, ablehnen) => { ... }) baut ein eigenes. Die Funktion, die du hineingibst, läuft sofort, und darin wird irgendwann eines von beiden aufgerufen.
Das brauchst du seltener, als es aussieht. Fast alles, was heute asynchron ist, gibt schon ein Promise zurück, fetch in Abschnitt 16, die meisten Browser-Funktionen, jede halbwegs aktuelle Bibliothek. Selbst gebaut wird nur, wenn du etwas Altes umhüllen willst, das noch mit Callbacks arbeitet, oder wenn du eine Wartezeit brauchst.
Für den Alltag gibt es zwei Abkürzungen. Promise.resolve(wert) gibt ein bereits erfülltes Promise und Promise.reject(fehler) ein bereits abgelehntes. Praktisch ist das in Funktionen, die manchmal etwas laden müssen und manchmal schon alles wissen.
In der Aufgabe baust du ein Promise und verkettest es danach mit zwei then.
Zum Mitnehmen
Ein Promise wechselt genau einmal von schwebend auf erfüllt oder abgelehnt. Was ein then zurückgibt, kommt im nächsten an, und ein catch am Ende fängt die ganze Kette.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe im Editor, direkt im Browser geprüft
Öffnet sich mit dem Basis Konto.