mitmario.dev

Zwei Arten von Fehlern

Node.js Sandbox 4 Min Lesezeit 3 BeispieleLektion 1 von 7

Eine fehlende Datei und ein Tippfehler im Feldnamen landen im selben catch, und beide kommen als Null wieder heraus. Nur eine der beiden Nullen stimmt.

Die beiden Fehler gehören zu verschiedenen Sorten. Betriebsfehler sind Lagen, die im Betrieb vorkommen dürfen. Die Datei ist nicht da, das Netz ist weg, die Eingabe ist Unsinn, die Datenbank ist gerade belegt. Nichts davon ist ein Versagen deines Codes, und für so eine Lage kann ein Programm eine Antwort haben, etwa einen Standardwert oder eine Meldung an den, der gerade wartet.

Programmfehler sind Fehler im Code. Ein Feld wird gelesen, das es nicht gibt, eine Funktion bekommt zwei Argumente statt drei, ein Wert wird nie geprüft. Zur Laufzeit gibt es darauf keine Antwort. Da hilft nur eine Änderung am Code.

Ein catch für alles

Mit einem catch behauptest du, dass es für diese Lage eine Antwort gibt. Fängst du jeden Fehler ab, behauptest du das auch für Lagen, die du gar nicht kennst.

Ein try um die ganze Funktion
import { readFileSync } from "node:fs";

// Ein try um die ganze Funktion, und ein catch, der alles gleich behandelt.
function zaehlePosten(pfad) {
  try {
    const daten = JSON.parse(readFileSync(pfad, "utf8"));
    // Tippfehler: das Feld heisst "posten", nicht "positionen".
    return daten.positionen.length;
  } catch (fehler) {
    return 0;
  }
}

console.log(`Datei fehlt:  ${zaehlePosten("gibtsnicht.json")}`);
console.log(`Datei ist da: ${zaehlePosten("bericht.json")}`);

Beim ersten Aufruf fehlt die Datei, und die Null ist eine ehrliche Antwort. Beim zweiten Aufruf ist die Datei da, sie enthält zwei Posten, und die Null ist gelogen. Das Feld heißt posten, im Code steht aber positionen. Den TypeError daraus hat der catch genauso weggeräumt wie vorher die fehlende Datei.

Das Programm läuft also mit einem falschen Wert weiter und reicht ihn an die nächste Stelle. Drei Funktionen später bucht jemand einen Betrag von null, und gesucht wird die Ursache dann dort, wo sie garantiert nicht ist.

Ein try um eine Zeile

Der try gehört nur um die Zeile oder die zwei Zeilen, für die es wirklich einen Plan B gibt.

Der enge try
import { readFileSync } from "node:fs";

// Derselbe Tippfehler, aber der try liegt nur um die Zeile, die scheitern darf.
function zaehlePosten(pfad) {
  let roh;
  try {
    roh = readFileSync(pfad, "utf8");
  } catch (fehler) {
    if (fehler.code !== "ENOENT") throw fehler;
    return 0;
  }

  const daten = JSON.parse(roh);
  return daten.positionen.length;
}

console.log(`Datei fehlt:  ${zaehlePosten("gibtsnicht.json")}`);
console.log(`Datei ist da: ${zaehlePosten("bericht.json")}`);

Derselbe Tippfehler, dasselbe Programm, ein anderer Ausgang. Der fehlende Pfad wird abgefangen, und zwar gezielt über err.code wie in Lektion 3.5. Alles andere fliegt weiter, und das Programm stürzt mit TypeError: Cannot read properties of undefined (reading 'length') ab.

Ein Absturz sieht schlimmer aus als eine Null. Er ist trotzdem besser, weil er an der Stelle passiert, an der der Fehler ist. Der Stacktrace zeigt auf die Zeile, und in zwei Minuten ist sie behoben. Die Null zeigt auf nichts.

Im Terminal stehen bei diesem Beispiel drei Fundstellen. Der Ort oben und die Zeile in zaehlePosten zeigen beide auf Zeile 14, also auf das .length. Die dritte zeigt auf Zeile 18, den Aufruf, der dorthin geführt hat. Ein Klick darauf stellt den Editor an die Stelle. Beim ersten Beispiel gibt es nichts zu klicken, dort steht eine Null.

Zum engen catch gehört auch seine zweite Hälfte. if (fehler.code !== "ENOENT") throw fehler; wirft alles zurück, was nicht dazugehört. Auch beim Lesen einer Datei kann es ein Rechteproblem geben oder eine volle Platte. Für so etwas hat diese kleine Funktion keine Antwort, und darum soll sich jemand weiter oben kümmern, der mehr über die Lage weiß.

Eigene Fehlerklassen

Auf err.code zu prüfen klappt, solange Node den Fehler wirft. Für eigene Fehler brauchst du dasselbe. Weiter oben soll jemand darauf reagieren können, ohne Meldungstexte zu vergleichen.

Eine eigene Fehlerklasse mit cause
// Eine eigene Fehlerklasse: ein Name, ein Code und der ursprüngliche Fehler.
class KonfigFehler extends Error {
  constructor(meldung, ursache) {
    super(meldung, { cause: ursache });
    this.name = "KonfigFehler";
    this.code = "konfig_kaputt";
  }
}

function ladeKonfig(roh) {
  try {
    return JSON.parse(roh);
  } catch (fehler) {
    throw new KonfigFehler("Die Konfiguration ist kein gültiges JSON", fehler);
  }
}

try {
  ladeKonfig("{ waehrung: EUR }");
} catch (fehler) {
  console.log(`Name:     ${fehler.name}`);
  console.log(`Code:     ${fehler.code}`);
  console.log(`Meldung:  ${fehler.message}`);
  console.log(`Ursache:  ${fehler.cause.name}`);
  console.log(`Ist ein KonfigFehler: ${fehler instanceof KonfigFehler}`);
  console.log(`Ist ein Error:        ${fehler instanceof Error}`);
}

class KonfigFehler extends Error reicht dafür, und drei Dinge kommen dabei mit:

  • Ein name, damit der Fehler im Protokoll mit seinem Namen steht und nicht nur als „Error“.
  • Ein code, damit eine Prüfung weiter oben stabil ist. Meldungstexte werden umformuliert, übersetzt oder ergänzt, und jedes Mal geht eine Prüfung auf den Text kaputt, ohne dass es jemand merkt. Für err.code aus Node galt dieselbe Regel.
  • instanceof funktioniert in beide Richtungen. Ein KonfigFehler ist ein KonfigFehler und ein Error, und ein catch weiter oben kann grob oder fein reagieren.

Den ursprünglichen Fehler mitnehmen

Der zweite Parameter von super(meldung, { cause: ursache }) löst ein altes Problem. Fängst du einen Fehler und wirfst einen aussagekräftigeren, ist der ursprüngliche sonst weg.

Mit cause hängt er dran. Oben steht der eigene Satz („Die Konfiguration ist kein gültiges JSON“). Darunter hängt der SyntaxError, der es wirklich gemerkt hat, mit seinem eigenen Stacktrace. Node zeigt die ganze Kette von selbst an, wenn der Fehler ausgegeben wird. Im Code kommst du über fehler.cause an jede Ebene heran.

throw fehler; gibt denselben Fehler weiter. throw new EigenerFehler("...", fehler); legt eine Schicht Bedeutung darüber und behält die alte.

In der Aufgabe fängt jeder try-Block in verarbeitung.js alles, was ihm begegnet.

Zum Mitnehmen

Ein catch gehört nur um die Lage, für die es eine Antwort gibt, und erkannt wird sie an code oder instanceof statt am Text der Meldung. Ein Programmfehler fliegt weiter und zeigt mit seinem Stacktrace auf die Zeile, die behoben werden muss.

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.