mitmario.dev

try/catch und async

Node.js Sandbox 3 Min Lesezeit 3 BeispieleLektion 2 von 7

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.

Der catch, der nichts fängt
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.

return gegen return await
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.

Behandeln, umwandeln, weiterwerfen
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, kostenlos

Zu 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.