JavaScript Fehlerbehandlung: Strategien für robuste Anwendungen

try, catch und finally, eigene Fehlerklassen mit cause, abgelehnte Promises und globale Handler: wie Fehler gezielt behandelt statt verschluckt werden
Aktualisiert:
Abstract
- #JavaScript
- #Error Handling
- #Fehlerbehandlung
- #async/await
- #Promises
- #Entwicklung
- #Web Development
- #Programming
Ein Fehler ist selten das Problem – gefährlich wird er erst, wenn ihn niemand bemerkt oder jeder ihn auf eigene Weise abfängt
Angenommen, in einem Webshop klickt eine Kundin auf „Jetzt kaufen“, und nichts passiert. Kein Hinweis, kein Ladesymbol, der Knopf bleibt grau. In der Browserkonsole steht eine einzige rote Zeile: Uncaught (in promise) TypeError: Failed to fetch. Der Server war für ein paar Sekunden nicht erreichbar, das kommt vor. Das eigentliche Problem ist ein anderes: Der Code hat mit diesem Fall nicht gerechnet, und niemand im Team hat davon erfahren.
Fehlerbehandlung heißt deshalb nicht, möglichst viele try-Blöcke zu schreiben. Es geht um drei Fragen: Welche Fehler sind erwartbar und brauchen eine Antwort für die Nutzer? Welche sind Programmierfehler und müssen laut auffallen? Und wo im Code wird jeweils entschieden? Die folgenden Abschnitte zeigen die Werkzeuge, die modernes JavaScript dafür mitbringt, mit Beispielen für Browser und Node.js.
Welche Fehler JavaScript kennt und welche es verschweigt
JavaScript signalisiert Fehler, indem es ein Objekt wirft. Die eingebauten Typen erben alle von Error: Ein TypeError entsteht etwa beim Zugriff auf eine Eigenschaft von null, ein ReferenceError bei einer nicht deklarierten Variable, ein RangeError bei einer ungültigen Array-Länge, ein SyntaxError bei kaputtem JSON in JSON.parse. Jedes Fehlerobjekt hat eine Meldung (message), einen Typnamen (name) und in allen gängigen Umgebungen einen Stacktrace (stack), also die Liste der Funktionsaufrufe bis zur Fehlerstelle.
Syntaxfehler im Quellcode selbst nehmen eine Sonderrolle ein. Die Engine erkennt sie beim Einlesen eines Skripts oder Moduls, bevor auch nur eine Zeile davon läuft. Ein vergessenes Komma bricht also nicht mitten im Ablauf ab, das ganze Skript startet gar nicht erst. In der Praxis fängt solche Fehler heute ohnehin der Editor, ein Linter oder der Build ab.
Tückischer sind die Fälle, in denen JavaScript gar keinen Fehler wirft. 'abc' / 2 ergibt NaN, ein Tippfehler im Eigenschaftsnamen liefert undefined, und beides wandert still weiter durch die Anwendung, bis irgendwo eine Rechnung über NaN € erscheint. Gegen diese Klasse hilft keine Fehlerbehandlung zur Laufzeit, sondern eine Typprüfung vor dem Ausführen, etwa mit TypeScript, und Validierung an den Stellen, an denen Daten von außen hereinkommen.
Für die Behandlung ist eine zweite Unterscheidung wichtiger als der Typ. Erwartbare Fehler gehören zum normalen Betrieb: Das Netz fällt aus, eine Datei fehlt, ein Formularfeld ist leer. Darauf braucht der Code eine Antwort. Programmierfehler wie der Zugriff auf undefined sind Bugs. Sie lassen sich nicht sinnvoll „behandeln“, sondern müssen gefunden und behoben werden. Wer beides im selben catch-Block verschwinden lässt, versteckt die Bugs hinter einer freundlichen Meldung.
try, catch und finally gezielt einsetzen
Der try-Block umschließt Code, der fehlschlagen kann. Wirft er, springt die Ausführung in catch. Der finally-Block läuft in jedem Fall, nach Erfolg wie nach Fehler, und eignet sich zum Aufräumen. Ein typisches Beispiel ist ein Absendeknopf, der während der Anfrage gesperrt wird:
async function absenden(knopf, daten) {
knopf.disabled = true;
try {
await sendeBestellung(daten);
} finally {
knopf.disabled = false; // läuft bei Erfolg und bei Fehler
}
}
Hier fehlt catch bewusst. Die Funktion weiß nicht, wie ein Fehler den Nutzern angezeigt werden soll, also reicht sie ihn an den Aufrufer weiter und sorgt nur dafür, dass der Knopf nicht dauerhaft gesperrt bleibt.
Wo catch steht, sollte es gezielt sein. Das folgende Beispiel für Node.js lädt eine Konfigurationsdatei. Fehlt sie, gelten Standardwerte, denn das ist erwartbar. Jeder andere Lesefehler wird weitergereicht:
// einstellungen.js (Node.js, ES-Modul)
import { readFile } from 'node:fs/promises';
const STANDARD = { sprache: 'de', seitengroesse: 20 };
export async function ladeEinstellungen(pfad) {
let text;
try {
text = await readFile(pfad, 'utf8');
} catch (error) {
if (error.code === 'ENOENT') return { ...STANDARD }; // Datei fehlt: erwartbar
throw error; // keine Leserechte, defekter Datenträger …: weiterreichen
}
try {
return { ...STANDARD, ...JSON.parse(text) };
} catch (error) {
throw new Error(`Einstellungen in ${pfad} sind kein gültiges JSON`, {
cause: error,
});
}
}
Drei Regeln stecken darin. Erstens: Der try-Block ist so klein wie möglich, damit klar ist, welcher Fehler gemeint ist. Zweitens: Was nicht erwartet ist, wird mit throw error unverändert weitergeworfen. Drittens: Ein leerer catch-Block, der nur console.log aufruft und dann weitermacht, ist fast immer ein Fehler. Wer einen Fehler wirklich ignorieren will, schreibt das ausdrücklich mit einem Kommentar hin.
Geworfen werden sollten ausschließlich Error-Objekte oder Unterklassen davon. JavaScript erlaubt zwar auch throw 'Fehler', doch ein String hat keinen Stacktrace, und jede Stelle, die error.message liest, geht leer aus.
Eigene Fehlerklassen und die Ursache mit cause
Sobald Aufrufer unterschiedlich auf Fehler reagieren sollen, lohnen sich eigene Klassen. Statt Meldungstexte zu vergleichen, prüft der Aufrufer mit instanceof den Typ. Seit ES2022 nimmt der Error-Konstruktor außerdem die Option cause an. Damit lässt sich ein technischer Fehler in einen verständlicheren einpacken, ohne die ursprüngliche Information zu verlieren:
// fehler.js
export class ApiFehler extends Error {
name = 'ApiFehler';
constructor(message, { status, cause } = {}) {
super(message, { cause });
this.status = status;
}
}
export class NichtGefundenFehler extends ApiFehler {
name = 'NichtGefundenFehler';
constructor(message, options = {}) {
super(message, { ...options, status: 404 });
}
}
export async function holeJson(url, { timeoutMs = 8000 } = {}) {
let antwort;
try {
antwort = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
} catch (error) {
// Netzwerkfehler oder Zeitüberschreitung (TimeoutError)
throw new ApiFehler(`Keine Antwort von ${url}`, { cause: error });
}
if (antwort.status === 404) {
throw new NichtGefundenFehler(`Nicht gefunden: ${url}`);
}
if (!antwort.ok) {
throw new ApiFehler(`HTTP ${antwort.status} bei ${url}`, {
status: antwort.status,
});
}
return antwort.json();
}
Das Beispiel enthält eine Falle, über die viele stolpern: fetch lehnt sein Promise nur bei Netzwerkfehlern ab. Eine Antwort mit Status 404 oder 500 gilt aus Sicht von fetch als Erfolg. Deshalb prüft der Code antwort.ok selbst. AbortSignal.timeout bricht die Anfrage nach der angegebenen Zeit ab, sonst kann sie je nach Umgebung sehr lange hängen.
Der Aufrufer entscheidet dann anhand des Typs, was die Nutzer sehen:
try {
const produkt = await holeJson('/api/produkte/42');
zeigeProdukt(produkt);
} catch (error) {
if (error instanceof NichtGefundenFehler) {
zeigeHinweis('Dieses Produkt ist nicht mehr im Sortiment.');
} else if (error instanceof ApiFehler) {
zeigeHinweis(
'Der Server ist gerade nicht erreichbar. Bitte versuchen Sie es später erneut.',
);
} else {
throw error; // Programmierfehler nicht verstecken
}
}
Die Ursache bleibt im Feld cause erhalten. Node.js gibt sie bei console.error mit aus, und gängige Monitoring-Werkzeuge werten sie ebenfalls aus. So steht im Fehlerbericht nicht nur „Keine Antwort“, sondern auch, ob es eine Zeitüberschreitung oder ein DNS-Problem war.
Eine Einschränkung von instanceof: Stammt ein Fehler aus einem anderen Kontext, etwa einem iframe oder einem vm-Kontext in Node.js, schlägt die Prüfung auf Error fehl, weil jeder Kontext eigene Klassen hat. Für diesen Fall gibt es die neue statische Methode Error.isError(). Node.js 24 kennt sie bereits, die Unterstützung in den Browsern, die Ihre Nutzer verwenden, sollten Sie vor dem Einsatz prüfen.
Asynchrone Fehler: await, abgelehnte Promises und parallele Aufrufe
Mit async und await sieht asynchroner Code aus wie synchroner, und try/catch funktioniert wie gewohnt. Ein Promise, das abgelehnt wird, verhält sich nach await wie ein geworfener Fehler. Die häufigste Fehlerquelle ist ein vergessenes await: Dann läuft der Aufruf weiter, das catch drumherum greift nicht, und der Fehler landet als unbehandelte Ablehnung im Nirgendwo. Linter-Regeln wie no-floating-promises aus typescript-eslint finden solche Stellen zuverlässig.
Werden mehrere Anfragen parallel gestartet, ist die Wahl der Kombinationsfunktion eine fachliche Entscheidung:
Promise.allbricht beim ersten Fehler ab. Richtig, wenn das Ergebnis ohne einen Teil wertlos ist, etwa Kopf und Positionen einer Rechnung.Promise.allSettledwartet auf alle und meldet je Aufruf Erfolg oder Fehler. Richtig, wenn Teilergebnisse sinnvoll sind.Promise.anyliefert das erste erfolgreiche Ergebnis und scheitert nur, wenn alle scheitern, dann mit einemAggregateError, der alle Einzelfehler im Felderrorssammelt.
Angenommen, eine Produktseite lädt Lagerbestand, Preise und Kundenbewertungen. Fehlen die Bewertungen, soll die Seite trotzdem erscheinen:
const ergebnisse = await Promise.allSettled([
holeJson('/api/lager/42'),
holeJson('/api/preise/42'),
holeJson('/api/bewertungen/42'),
]);
const [lager, preise, bewertungen] = ergebnisse.map((e) =>
e.status === 'fulfilled' ? e.value : null,
);
const fehler = ergebnisse
.filter((e) => e.status === 'rejected')
.map((e) => e.reason);
if (fehler.length > 0) {
melde(new AggregateError(fehler, 'Produktseite teilweise nicht geladen'));
}
Die Seite zeigt, was da ist, und für die fehlenden Teile einen Platzhalter. Ob ohne Preis überhaupt etwas angezeigt werden darf, ist dagegen eine Frage an die Fachabteilung, nicht an den Code. Ein AggregateError lässt sich auch selbst erzeugen, wie hier, um mehrere Fehler als einen zu melden.
Was durchrutscht: globale Handler als letzte Verteidigungslinie
Kein Team fängt jeden Fehler an der richtigen Stelle. Für das, was durchrutscht, bieten Browser und Node.js globale Ereignisse. Im Browser meldet das Ereignis error auf window nicht abgefangene Fehler, unhandledrejection abgelehnte Promises ohne Behandlung:
window.addEventListener('error', (event) => {
melde(event.error ?? new Error(event.message));
});
window.addEventListener('unhandledrejection', (event) => {
melde(event.reason);
});
Diese Handler sind zum Protokollieren gedacht, nicht zum Reparieren. Sie wissen nicht, welche Aktion gerade fehlgeschlagen ist, und können den Nutzern keine passende Meldung zeigen.
In Node.js beendet eine unbehandelte Promise-Ablehnung den Prozess seit Version 15 standardmäßig, genau wie ein nicht abgefangener Fehler. Das ist gewollt: Ein Prozess in unbekanntem Zustand sollte nicht einfach weiterlaufen. Ein globaler Handler protokolliert den Fehler und beendet den Prozess dann selbst, ein Prozessmanager oder die Container-Plattform startet ihn neu:
// Letzte Verteidigungslinie in Node.js: protokollieren und beenden
process.on('uncaughtException', (error, herkunft) => {
console.error(`Unbehandelter Fehler (${herkunft}):`, error);
process.exit(1); // Prozessmanager oder Container startet neu
});
Der zweite Parameter verrät, ob es ein geworfener Fehler (uncaughtException) oder eine nicht behandelte Ablehnung (unhandledRejection) war. Wer stattdessen einen Handler für unhandledRejection registriert und den Prozess weiterlaufen lässt, schaltet das sichere Standardverhalten ab.
Fehler an Systemgrenzen abfangen und übersetzen
Die meisten erwartbaren Fehler entstehen dort, wo Daten die eigene Anwendung betreten oder verlassen: Netzwerkaufrufe, Dateien, Benutzereingaben, localStorage, Nachrichten aus einer Warteschlange. An diesen Grenzen lohnt sich die meiste Sorgfalt. Ein Beispiel ist ein Warenkorb, der im Browser gespeichert wird. Ein beschädigter Eintrag, etwa nach einem Update mit geändertem Format, soll die Seite nicht lahmlegen:
function leseWarenkorb() {
const roh = localStorage.getItem('warenkorb');
if (roh === null) return [];
try {
const daten = JSON.parse(roh);
return Array.isArray(daten) ? daten : [];
} catch {
localStorage.removeItem('warenkorb'); // beschädigten Eintrag verwerfen
return [];
}
}
Der catch-Block ohne Variable ist seit ES2019 erlaubt und signalisiert: Der Fehler selbst interessiert hier nicht, die Reaktion ist eindeutig. Für komplexere Daten ersetzen Schema-Bibliotheken wie Zod oder Valibot die handgeschriebene Prüfung und liefern verständliche Meldungen, welches Feld nicht passt.
An der Grenze nach außen gilt das Gegenteil: Fehler werden übersetzt, nicht durchgereicht. Ein API-Server gibt bei einer Datenbankstörung keinen Stacktrace mit Tabellennamen zurück, sondern einen Statuscode und eine knappe Meldung, während die Details ins Log gehen. Im Frontend sieht die Kundin „Bitte versuchen Sie es später erneut“, nicht TypeError: Cannot read properties of undefined. Diese Übersetzung gehört an eine zentrale Stelle, etwa eine Fehler-Middleware im Server oder eine Fehlergrenze in React, statt in jede einzelne Funktion. Wie Error Boundaries in React funktionieren und wie Sie Fehler in Komponenten aufspüren, zeigt der Beitrag zu Debugging in React.
Fehler sichtbar machen: Logging und Monitoring
Ein Fehler, der nur in der Konsole eines Kunden erscheint, existiert für das Team nicht. Für Produktivsysteme gehört deshalb ein Fehler-Monitoring dazu. Werkzeuge wie Sentry oder auf OpenTelemetry aufbauende Lösungen sammeln Fehler aus Browser und Server, gruppieren gleichartige Fälle und zeigen, wie oft sie auftreten. Damit die Stacktraces lesbar sind, braucht das Werkzeug die Source Maps des Builds, also die Zuordnung vom ausgelieferten, verkleinerten Code zum Quelltext. Wie Source Maps beim Debuggen helfen, beschreibt der Beitrag TypeScript debuggen.
Zwei Punkte werden dabei oft übersehen. Fehlerberichte enthalten schnell personenbezogene Daten, etwa E-Mail-Adressen in URLs oder Formularinhalte. Für sie gilt die DSGVO, also auch die Frage, wo der Dienst die Daten verarbeitet und ob ein Vertrag zur Auftragsverarbeitung nötig ist. Und ein Monitoring, das täglich Hunderte Meldungen schickt, wird ignoriert. Besser ist es, wenige, aussagekräftige Fehler zu melden und bekannte, erwartbare Fälle gar nicht erst als Fehler zu protokollieren.
Was das für Ihr Team bedeutet
Gute Fehlerbehandlung ist weniger eine Frage der Syntax als eine Teamvereinbarung. Unsere Empfehlung: Legen Sie fest, welche Fehlerklassen es gibt und wo sie behandelt werden, typischerweise an den Systemgrenzen und an einer zentralen Stelle pro Schicht. Dazwischen wird nicht gefangen, sondern weitergereicht. Programmierfehler bleiben laut und landen im Monitoring, erwartbare Fehler bekommen eine verständliche Meldung für die Nutzer.
Überschätzt wird dagegen der Nutzen von try/catch an jeder Ecke. Mehr Fangstellen machen Code nicht robuster, sondern undurchsichtiger, weil niemand mehr weiß, wo ein Fehler eigentlich verschwunden ist. Wer TypeScript nutzt, verschiebt zusätzlich einen großen Teil der stillen Fehler wie undefined und NaN von der Laufzeit in den Editor. In unseren Seminaren zu TypeScript gehören Fehlerstrategien und typsichere Fehlerbehandlung deshalb zum Programm.
Häufige Fragen zur Fehlerbehandlung in JavaScript
Fängt try/catch auch Fehler in Callbacks wie setTimeout?
Nein. Ein try-Block erfasst nur Code, der synchron in ihm läuft, oder Promises, auf die mit await gewartet wird. Ein Callback, der später von setTimeout oder einem Event-Listener aufgerufen wird, läuft außerhalb des Blocks und braucht eine eigene Behandlung.
Sollte man then/catch oder async/await verwenden?
Beides ist gleichwertig, async/await ist meist lesbarer, weil Fehlerbehandlung und Ablauf wie in synchronem Code aussehen. .catch() bleibt praktisch, wenn ein einzelnes Promise ohne eigene Funktion abgesichert werden soll.
Was ist der Unterschied zwischen einem Fehler und einer Ablehnung?
Ein Fehler wird mit throw geworfen, ein Promise wird mit einem Grund abgelehnt (rejected). Innerhalb einer async-Funktion wird aus throw automatisch eine Ablehnung, und ein await auf ein abgelehntes Promise wirft wieder. Für die Behandlung macht das deshalb kaum einen Unterschied, solange überall await steht.
Wenn Sie Fehlerstrategien für eine bestehende Webanwendung festlegen oder Ihr Frontend robuster machen möchten, unterstützen wir Sie im Rahmen der Web- und App-Entwicklung.
Kategorien
Schlagworte