Abschnitt 16 · Lektion 2
try/catch und async
Der Code sieht richtig aus. Der try steht da, der catch steht da, und trotzdem stürzt das
Programm ab, weil vor einem einzigen Aufruf ein Wort fehlt.
Warum der catch danebensteht
Ein try/catch fängt, was innerhalb des Blocks geworfen wird. Eine async-Funktion wirft aber nie
zu ihrem Aufrufer. Scheitert sie, legt sie den Fehler in das Promise, das sie zurückgibt, auch wenn
es gleich in ihrer ersten Zeile passiert. Erst ein await packt ihn wieder aus und wirft ihn an der
Stelle, an der es steht. Fehlt das await, verlässt die Funktion den try mit einem abgelehnten
Promise in der Hand, und der catch bekommt davon überhaupt nichts mit.
async function kaputt() {
throw new Error("Datenbank weg");
}
// Ohne await bleibt der Fehler im Promise, und der catch sieht ihn nie.
async function ohneAwait() {
try {
kaputt();
return "durchgelaufen";
} catch (fehler) {
return "gefangen";
}
}
async function mitAwait() {
try {
await kaputt();
return "durchgelaufen";
} catch (fehler) {
return "gefangen";
}
}
// Nur damit das Beispiel nicht abstuerzt, bevor es etwas gezeigt hat.
process.on("unhandledRejection", (grund) => {
console.log(`später, unbehandelt: ${grund.message}`);
});
const ohne = await ohneAwait();
console.log(`ohne await: ${ohne}`);
const mit = await mitAwait();
console.log(`mit await: ${mit}`); Die beiden Funktionen unterscheiden sich in einem Wort. Die erste läuft durch, als sei nichts gewesen, und meldet den Erfolgswert. Die zweite fängt, wie man es erwartet.
Der eigentliche Fehler steht in der Zeile später, unbehandelt: Datenbank weg. Das abgelehnte
Promise ist nicht verschwunden. Es kommt nur später und findet niemanden. Der Listener für
unhandledRejection steckt nur zur Vorführung im Beispiel, ohne ihn würde Node den Prozess an
dieser Stelle beenden. Was dahintersteckt, steht in Lektion 16.4.
Lässt du ein Promise mit Absicht ohne await loslaufen, braucht es sein eigenes .catch(). Am
besten steht das auf derselben Zeile, dann sieht man beim Lesen gleich, dass es Absicht war.
return gegen return await
Bei return innerhalb eines try entscheidet das scheinbar überflüssige await darüber, wo der
Fehler landet.
import { readFile } from "node:fs/promises";
async function mitReturn() {
try {
return readFile("gibtsnicht.txt", "utf8");
} catch (fehler) {
return "Standardwert";
}
}
async function mitReturnAwait() {
try {
return await readFile("gibtsnicht.txt", "utf8");
} catch (fehler) {
return "Standardwert";
}
}
try {
console.log(`return: ${await mitReturn()}`);
} catch (fehler) {
console.log(`return: geplatzt beim Aufrufer (${fehler.code})`);
}
console.log(`return await: ${await mitReturnAwait()}`); return readFile(...) gibt das Promise zurück, und die Funktion ist damit fertig. Der try-Block
ist verlassen, bevor die Datei überhaupt gesucht wurde. Lehnt das Promise dann ab, platzt es beim
Aufrufer. Der catch ein paar Zeilen darüber kommt gar nicht erst dran.
return await readFile(...) wartet noch innerhalb des try. Erst der ausgepackte Wert wird
zurückgegeben, und ein Fehler landet im catch dieser Funktion.
Außerhalb eines try ändert return await am Ergebnis nichts. Die Funktion bleibt damit aber im
Stacktrace stehen, ohne await fehlt sie dort. Ich schreibe es überall hin, wo ich auf ein Promise
warte, auch ohne try drumherum.
Was in einen catch gehört
Manche catch-Blöcke protokollieren nur und machen dann weiter, als sei nichts gewesen. Damit ist
der Fehler hinter einem Protokolleintrag versteckt. Das Programm läuft mit halben Daten weiter, und
im Protokoll steht eine Zeile, die niemand liest, weil ja alles zu funktionieren scheint.
Drei Inhalte ergeben Sinn, und ein catch ohne einen davon gehört weg.
class BestellFehler extends Error {
constructor(meldung, ursache) {
super(meldung, { cause: ursache });
this.name = "BestellFehler";
this.code = "bestellung_kaputt";
}
}
async function lade() {
throw new Error("Zeitüberschreitung nach 2000 ms");
}
// 1. Behandeln: es gibt eine Antwort, also gib sie.
async function behandeln() {
try {
return await lade();
} catch (fehler) {
return "aus dem Zwischenspeicher";
}
}
// 2. Umwandeln: der Aufrufer bekommt etwas, mit dem er umgehen kann.
async function umwandeln() {
try {
return await lade();
} catch (fehler) {
throw new BestellFehler("Die Bestellung ließ sich nicht laden", fehler);
}
}
// 3. Weiterwerfen: hier ist nicht der Ort dafuer. Aufraeumen aber schon.
async function weiterwerfen() {
console.log("weiterwerfen: Verbindung offen");
try {
return await lade();
} finally {
console.log("weiterwerfen: Verbindung geschlossen");
}
}
const behandelt = await behandeln();
console.log(`behandeln: ${behandelt}`);
try {
await umwandeln();
} catch (fehler) {
console.log(`umwandeln: ${fehler.name}, Ursache ${fehler.cause.message}`);
}
try {
await weiterwerfen();
} catch (fehler) {
console.log(`weiterwerfen: ${fehler.message} kam beim Aufrufer an`);
} Behandeln heißt, dass es für diese Lage eine Antwort gibt, und die wird jetzt gegeben. Die Antwort aus dem Zwischenspeicher, ein Standardwert, ein leeres Ergebnis. Das ist der Fall aus der vorigen Lektion.
Umwandeln heißt, dass der Fehler echt ist, der Aufrufer in dieser Form aber nichts damit anfangen
kann. Daraus wird ein eigener Fehler, der den ursprünglichen über cause mitnimmt. Aus einer
Zeitüberschreitung wird ein BestellFehler, und wer den fängt, weiß, was schiefging, ohne die
Innereien zu kennen.
Weiterwerfen heißt, dass hier nicht der richtige Ort dafür ist, und dann braucht es streng genommen
gar keinen catch, sondern nur ein finally für das Aufräumen am Ende. Ein try ohne catch ist
in Ordnung. Gefangen wird dann nichts, aufgeräumt aber auf jeden Fall.
Wofür finally gut ist
finally läuft immer. Nach dem return im Erfolgsfall, nach dem catch, und auch dann, wenn der
Fehler durchfliegt und diese Funktion gar nicht mehr zuständig ist.
Aufgeräumt wird dort alles, was auf jeden Fall aufgeräumt gehört. Eine Datei schließen, eine Datenbankverbindung zurückgeben, ein Sperrkennzeichen entfernen, einen Zähler zurücksetzen. Im dritten Fall des Beispiels siehst du die Reihenfolge. Erst wird die Verbindung geschlossen, danach kommt der Fehler beim Aufrufer an.
Der Erfolgsfall gehört dagegen nicht in ein finally. Wer dort das Ergebnis verarbeitet oder eine
Antwort schickt, tut das auch dann, wenn gerade alles schiefgegangen ist.
In aufgaben.js steckt in jeder der vier Funktionen ein Fehler dieser Art.
Zum Mitnehmen
Ohne await im try geht ein abgelehntes Promise am catch vorbei, auch hinter return. Im catch wird ein Fehler behandelt, umgewandelt oder weitergeworfen, und aufgeräumt wird im finally.
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.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.