Fehlerbehandlung in TypeScript: try/catch und mehr: von A bis Z

Fehlerbehandlung in TypeScript: von try/catch bis zu komplexen Szenarien

TypeScript, als Erweiterung von JavaScript, erbt und erweitert die Mechanismen zur Fehlerbehandlung. Die korrekte Behandlung von Ausnahmen ist der Schlüssel zu einer stabilen und vorhersagbaren Anwendung. In diesem Artikel werden wir alle Aspekte der Arbeit mit Fehlern behandeln: vom grundlegenden try/catch bis zur Erstellung eigener typisierter Fehlerklassen und fortgeschrittener Strategien.

Grundlegende Syntax: try, catch, finally

Der grundlegende Mechanismus zur Fehlerbehandlung in TypeScript (wie auch in JavaScript) ist die try...catch...finally-Konstruktion. Sie ermöglicht es, Ausnahmen, die im Code auftreten, abzufangen und darauf zu reagieren.

function parseJSON(data: string): object {    try {        return JSON.parse(data);    } catch (error) {        console.error('Fehler beim JSON-Parsen:', error);        return {};    }}

parseJSON('{"name": "TypeScript"}'); // { name: 'TypeScript' }parseJSON('ungültiges JSON');        // {} (Fehler abgefangen)

Der finally-Block wird in jedem Fall ausgeführt – sowohl nach erfolgreichem Abschluss des try-Blocks als auch nach dem Abfangen eines Fehlers. Dies ist der ideale Ort für die Bereinigung von Ressourcen (Schließen von Dateien, Verbindungen).

function processData(data: string): void {    let resource: any = null;    try {        resource = acquireResource();        // ... gefährlicher Code    } catch (error) {        console.error('Verarbeitungsfehler:', error);    } finally {        if (resource) {            resource.release(); // garantierte Bereinigung        }    }}

Fehlertypisierung: Das Problem mit unknown

Eine wichtige Besonderheit von TypeScript – im catch-Block hat die Variable error standardmäßig den Typ unknown (seit TS 4.0). Dies wurde absichtlich so gemacht, um den Entwickler zu zwingen, den Fehlertyp explizit zu überprüfen, anstatt anzunehmen, dass es sich um Error handelt.

try {    // irgendein Code} catch (error) {    // error hat den Typ unknown    // Fehler: Eigenschaft 'message' existiert nicht auf Typ 'unknown'    // console.log(error.message);

    // Korrekter Ansatz – Typüberprüfung    if (error instanceof Error) {        console.log('Nachricht:', error.message);    } else {        console.log('Unbekannter Fehler:', error);    }}

Warum ist das wichtig? In JavaScript kann in den catch-Block alles Mögliche gelangen: ein String, eine Zahl, ein Objekt, null oder sogar undefined. Die erzwungene Typüberprüfung schützt vor Fehlern zur Laufzeit.

Erstellung benutzerdefinierter Fehlerklassen

Für komplexe Anwendungen ist es oft erforderlich, verschiedene Fehlertypen zu unterscheiden. In TypeScript lässt sich leicht eine Hierarchie eigener Fehlerklassen erstellen, die den integrierten Error erweitern.

// Basisklasse für Anwendungsfehlerclass AppError extends Error {    public readonly statusCode: number;    public readonly isOperational: boolean;

    constructor(message: string, statusCode: number = 500, isOperational: boolean = true) {        super(message);        this.name = this.constructor.name;        this.statusCode = statusCode;        this.isOperational = isOperational;

        // Prototyp wiederherstellen (wichtig für instanceof)        Object.setPrototypeOf(this, new.target.prototype);    }}

// Konkrete Fehlertypenclass ValidationError extends AppError {    public readonly field: string;

    constructor(message: string, field: string) {        super(message, 400);        this.field = field;    }}

class NotFoundError extends AppError {    constructor(message: string = 'Ressource nicht gefunden') {        super(message, 404);    }}

// Verwendungfunction getUser(id: number): User {    if (id <= 0) {        throw new ValidationError('ID muss eine positive Zahl sein', 'id');    }    // ... Benutzersuche    throw new NotFoundError