mitmario.dev

Eigene Fehler werfen

JavaScript Im Browser 3 Min Lesezeit 3 BeispieleLektion 3 von 6

Bekommt eine Funktion falsche Eingaben und rechnet einfach weiter, liefert sie irgendwann NaN oder Infinity. Aufgefallen ist der Fehler dann erst drei Funktionen weiter, und dort weiß niemand mehr, woher er kommt. Deshalb dürfen eigene Funktionen auch selbst Fehler auslösen. Das klingt erst mal nach dem Gegenteil von guter Arbeit. Es spart aber Stunden Suche in Code, der viel weiter unten steht.

throw und was danach passiert

throw beendet die Funktion sofort
function alterPruefen(jahre) {
  console.log("Prüfe", jahre);
  if (jahre < 0) {
    throw new Error("Ein Alter kann nicht negativ sein");
  }
  console.log("Diese Zeile kommt nur bei gültigem Alter dran.");
  return jahre;
}

try {
  alterPruefen(34);
  alterPruefen(-5);
  console.log("Diese Zeile kommt nicht mehr dran.");
} catch (fehler) {
  console.error(fehler);
}

throw new Error("Text") tut zwei Dinge. Es baut ein Error-Objekt mit der Meldung, und es beendet die Funktion an dieser Stelle. Nichts, was danach in der Funktion steht, läuft noch.

Dann geht der Fehler nach oben, zum Aufrufer, zu dessen Aufrufer und so weiter, bis einer ein catch darum hat. Hat keiner eins, landet er als ungefangener Fehler in der Console, und das Programm steht.

Im ersten Beispiel siehst du beides. Der erste Aufruf läuft durch, der zweite bricht mitten in der Funktion ab. Auch der console.log direkt danach im try-Block kommt nicht mehr dran.

Werfen oder zurückgeben

Werfen oder zurückgeben
const lager = [
  { id: "a1", name: "Tastatur" },
  { id: "b2", name: "Maus" },
];

// Nichts gefunden ist ein erwartbarer Fall. Kein Wurf.
function suchen(id) {
  return lager.find((artikel) => artikel.id === id) ?? null;
}

// Eine fehlende id ist ein Fehler im aufrufenden Code. Wurf.
function suchenStreng(id) {
  if (typeof id !== "string" || id === "") {
    throw new Error(`suchenStreng erwartet eine id als Text, bekommen: ${typeof id}`);
  }
  return lager.find((artikel) => artikel.id === id) ?? null;
}

console.log("Vorhanden:", suchen("a1"));
console.log("Nicht vorhanden:", suchen("zzz"));

try {
  suchenStreng(undefined);
} catch (fehler) {
  console.error(fehler);
}

Das ist die eigentliche Frage dieser Lektion, und Geschmackssache ist sie nicht.

Geworfen wird, wenn der Aufrufer etwas falsch gemacht hat. Braucht eine Funktion eine Zahl und bekommt einen Text, kann sie nicht sinnvoll weiterarbeiten. Ein Rückgabewert wie null würde den Fehler nur weiterreichen, und drei Funktionen später taucht er als TypeError auf, wo niemand mehr weiß, wo er herkommt.

Ein Rückgabewert ist richtig, wenn der Fall vorgesehen ist. „Nichts gefunden“ ist kein Fehler, sondern ein ganz normales Ergebnis einer Suche. Der Aufrufer hat ja nichts falsch gemacht. Dafür passt null.

Im zweiten Beispiel stehen beide nebeneinander. suchen("zzz") liefert null, denn diesen Artikel gibt es nicht. suchenStreng(undefined) wirft, denn undefined ist keine id, und wer das übergibt, hat einen Fehler im Code.

Ich halte mich an eine einfache Unterscheidung. Ein Fehler ist etwas, das nicht passieren sollte. Alles, was passieren darf, ist ein Rückgabewert.

Immer ein Error, nie ein Text

Ein Error trägt mehr als ein Text
function mitText() {
  throw "So bitte nicht";
}

function mitError() {
  throw new Error("So ist es richtig");
}

try {
  mitText();
} catch (fehler) {
  console.log("Gefangen:", fehler);
  console.log("typeof:", typeof fehler);
  console.log("stack:", fehler.stack);
}

try {
  mitError();
} catch (fehler) {
  console.log("Gefangen:", fehler.message);
  console.log("typeof:", typeof fehler);
  console.log("stack vorhanden:", typeof fehler.stack === "string");
}

Werfen lässt sich technisch alles. throw "kaputt" ist gültiges JavaScript, throw 42 genauso. Ich lasse es trotzdem.

Im dritten Beispiel kommt der geworfene Text als Text an, ohne name und ohne stack. Damit fehlt die wichtigste Angabe, nämlich wo das passiert ist.

Dazu kommt ein praktischer Grund. Fremder Code, der deinen aufruft, geht davon aus, dass er ein Error fängt. Er liest fehler.message, und bei einem geworfenen Text steht dort undefined. Deshalb werfe ich immer ein new Error(...).

Was in die Meldung gehört

Eine gute Fehlermeldung beantwortet zwei Fragen. Was wurde erwartet, und was kam an?

"Ungültige Eingabe" beantwortet keine davon. "teile erwartet zwei Zahlen, bekommen: string und number" beantwortet beide, und wer das liest, weiß sofort, wonach er suchen muss.

Der Name der Funktion darf mit hinein, denn im Stacktrace steht er zwar sowieso, aber Meldungen wandern manchmal in Protokolle, in denen kein Stacktrace mehr dabei ist.

Was nicht in die Meldung gehört, sind Dinge, die niemanden etwas angehen. Passwörter, Schlüssel, ganze Datensätze. Eine Fehlermeldung landet schneller an einer öffentlichen Stelle, als einem lieb ist.

Eigene Fehlerarten

Für den Anfang reicht Error völlig aus. Man kann sich aber auch eigene Arten bauen und sie dann genauso benutzen wie TypeError und die anderen.

Dafür braucht es Klassen, und die kommen in Abschnitt 18. Mit eigenen Arten kann ein catch unterscheiden, um welche Sorte Problem es geht, ohne dafür im Meldungstext nach Stichwörtern zu suchen. Bis dahin tut es auch eine deutliche Meldung.

In der Aufgabe wehrt sich eine Funktion gegen falsche Eingaben, und eine zweite fängt ihren Fehler ab.

Zum Mitnehmen

Eine Funktion wirft, wenn der Aufrufer etwas falsch gemacht hat, und gibt einen Wert zurück, wenn der Fall vorgesehen ist. Geworfen wird immer ein Error-Objekt, denn nur das trägt name und stack.

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 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.