mitmario.dev

try, catch, finally

JavaScript Im Browser 4 Min Lesezeit 4 BeispieleLektion 2 von 6

Ein Text aus einem fremden Dienst ist kaputt, JSON.parse wirft, und ab dieser Zeile passiert nichts mehr. Bis jetzt hat ein Fehler das Programm immer angehalten. Meistens ist das auch richtig, denn einen Denkfehler im eigenen Code willst du laut merken.

Es gibt aber Stellen, an denen ein Fehler zum normalen Betrieb gehört. Ein Server antwortet nicht, eine Datei ist kaputt, jemand tippt Unsinn in ein Feld. Dort soll es weitergehen, und dafür gibt es try und catch.

Die Grundform

Mit und ohne try
const kaputt = "{ name: Mario }";

try {
  const daten = JSON.parse(kaputt);
  console.log("Gelesen:", daten);
} catch (fehler) {
  console.error("Gefangen:", fehler.message);
}

console.log("Das Programm läuft weiter.");

// Und jetzt ohne try. Ab hier passiert nichts mehr.
const nochmal = JSON.parse(kaputt);
console.log("Diese Zeile wird nie erreicht.");

JSON.parse ist hier nur das Beispiel für eine Funktion, die werfen kann. Sie macht aus einem Text ein Objekt, und wenn der Text nicht das erwartete Format hat, bricht sie ab. Was JSON ist, kommt in Lektion 16.1. Für jetzt reicht, dass { name: Mario } kein gültiges JSON ist.

try kommt um das, was schiefgehen kann. Geht alles gut, merkst du von catch nichts. Geht es schief, springt die Ausführung sofort in den catch-Block, mitten aus dem try heraus. Was danach im try stand, wird übersprungen.

Im Beispiel steht derselbe kaputte Text zweimal. Beim ersten Mal wird der Fehler abgefangen, es erscheint eine ordentliche Meldung, und das Programm läuft weiter. Beim zweiten Mal fehlt das try. Dann ist Schluss, und die letzte Zeile wird nie erreicht.

In der Console siehst du den Unterschied. Den gefangenen Fehler hat der eigene Code dort hingeschrieben, den ungefangenen meldet der Browser selbst, und darunter läuft kein Programm mehr.

Was im catch ankommt

Was im catch ankommt
try {
  const liste = null;
  liste.push(1);
} catch (fehler) {
  console.log("name:", fehler.name);
  console.log("message:", fehler.message);
  console.log("stack ist Text:", typeof fehler.stack === "string");

  // Lesbar wird der stack erst so, mit den Dateinamen.
  console.error(fehler);
}

In den Klammern hinter catch steht ein Name für den Wert, der geworfen wurde. Bei allem, was der Browser selbst wirft, ist das ein Error-Objekt mit drei nützlichen Eigenschaften.

  • name ist die Art aus der letzten Lektion, also TypeError, ReferenceError und so weiter.
  • message ist der Text ohne die Art davor.
  • stack ist der Stacktrace als ein einziger langer Text. Lesbar wird er mit console.error(fehler), dann steht er unter der Meldung, mit den eigenen Dateinamen.

Wenn du die Meldung nur für dich selbst ausgibst, reicht fehler.message fast immer. Für die Leute vor dem Bildschirm ist sie meistens nichts, denn mit „Cannot read properties of null“ kann niemand etwas anfangen, der nur ein Formular abschicken wollte.

Den Namen fehler darfst du frei wählen. In fremdem Code heißt er oft e oder err. Brauchst du ihn gar nicht, dürfen die Klammern wegfallen, und catch { reicht. Chrome, Firefox und Safari können das seit 2018.

finally

finally läuft immer
const button = document.getElementById("laden");

function verarbeiten(text) {
  button.disabled = true;
  console.log("Start, gesperrt:", button.disabled);
  try {
    return JSON.parse(text);
  } catch (fehler) {
    console.warn("Ging nicht:", fehler.message);
    return null;
  } finally {
    button.disabled = false;
    console.log("Aufgeräumt, gesperrt:", button.disabled);
  }
}

console.log("Ergebnis 1:", verarbeiten('{"name":"Ida"}'));
console.log("Ergebnis 2:", verarbeiten("kaputt"));

Nach catch darf noch ein finally stehen. Dieser Block läuft in jedem Fall. Nach einem erfolgreichen try, nach einem gefangenen Fehler und sogar dann, wenn im try ein return steht.

In finally wird aufgeräumt. Der typische Fall ist der gesperrte Absenden-Button aus Lektion 13.6. Er wird gesperrt, bevor die Arbeit losgeht, und hinterher wieder freigegeben. Steht die Freigabe am Ende des try, bleibt der Button nach einem Fehler für immer gesperrt, und das passiert im finally nicht.

Im Beispiel ist der Button während jedes Durchlaufs gesperrt und danach wieder frei. Auch nach dem zweiten, der schiefgegangen ist.

Wo try/catch hingehört, und wo nicht

Nach dieser Lektion ist die Versuchung groß, einfach alles einzupacken. Helfen tut es aber nur an wenigen Stellen.

try/catch gehört um das, was außerhalb der eigenen Kontrolle liegt, also um Netzwerkaufrufe, um JSON.parse mit fremden Daten und um alles, was von außen kommt. Dort ist ein Fehler kein Programmierfehler, sondern ein Betriebszustand.

Um den eigenen Code gehört es nicht. Wenn berechnePreis() wirft, steckt ein Fehler im Code, und den willst du sehen und beheben. Mit einem catch drumherum wird er unsichtbar, und das Programm rechnet einfach mit falschen Zahlen weiter.

Ein leeres catch verschluckt den Fehler
function preisLesen(text) {
  try {
    return JSON.parse(text).preis;
  } catch (fehler) {}
}

console.log("Preis:", preisLesen('{"preis": 4900}'));

// Der kaputte Text meldet keinen Fehler. Die Zeile zeigt
// nur undefined, und warum, erfährt niemand.
console.log("Preis:", preisLesen("{ preis: 4900 }"));

Am schlimmsten ist das leere catch. Im vierten Beispiel kommt in der zweiten Zeile keine Fehlermeldung, da steht nur undefined. Der kaputte Text ist weg, die Ursache aber nicht, und beim nächsten Mal suchst du an einer Stelle, an der gar nichts kaputt ist. Wenn ich wirklich nichts tun will, schreibe ich wenigstens ein console.warn hinein und eine Zeile Kommentar, warum das hier in Ordnung ist.

Was try/catch nicht fängt

try/catch fängt nur, was während des try-Blocks passiert. Wenn darin etwas für später vorgemerkt oder ein Klick-Handler hinterlegt wird, ist der try-Block längst vorbei, sobald dieser Code läuft. Ein Fehler dort geht am catch vorbei, als wäre es gar nicht da.

Das ist einer der Gründe, warum es Promises gibt. Abschnitt 15 kommt darauf zurück.

In der Aufgabe baust du eine Funktion so um, dass kaputter Text die Seite nicht anhält und danach in beiden Fällen aufgeräumt ist.

Zum Mitnehmen

try fängt ab, was im Block schiefgeht, catch bekommt den Fehler, und finally räumt in jedem Fall auf. Gebraucht wird das bei fremden Daten und fremden Diensten, und ein leeres catch verschluckt den Fehler samt Ursache.

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.

Was in dieser Lektion steckt

  • Artikel mit 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.