Fehlerbehandlung und Exception Handling

Geschätzte Lektüre: 4 Minuten 365 Ansichten

Robuste Fehlerbehandlung ist ein kritischer Aspekt der Softwareentwicklung. Moderne Programmiersprachen bieten strukturierte Exception-Handling-Mechanismen, die eine elegante Behandlung von Ausnahmesituationen ermöglichen:

// Try-Catch-Finally Struktur
function parseJSON(jsonString) {
    try {
        const data = JSON.parse(jsonString);
        console.log("JSON erfolgreich geparst");
        return data;
    } catch (error) {
        if (error instanceof SyntaxError) {
            console.error("Ungültiges JSON-Format:", error.message);
        } else {
            console.error("Unerwarteter Fehler:", error);
        }
        return null;
    } finally {
        console.log("JSON-Parsing-Versuch abgeschlossen");
    }
}

// Benutzerdefinierte Exceptions
class ValidationError extends Error {
    constructor(message, field) {
        super(message);
        this.name = "ValidationError";
        this.field = field;
    }
}

class NetworkError extends Error {
    constructor(message, statusCode) {
        super(message);
        this.name = "NetworkError";
        this.statusCode = statusCode;
    }
}

// Fehlerbehandlung in asynchronem Code
async function validateAndSave(userData) {
    try {
        // Validierung
        if (!userData.email || !userData.email.includes('@')) {
            throw new ValidationError("Ungültige E-Mail-Adresse", "email");
        }
        
        // Netzwerk-Operation
        const response = await fetch('/api/users', {
            method: 'POST',
            body: JSON.stringify(userData)
        });
        
        if (!response.ok) {
            throw new NetworkError("Server-Fehler", response.status);
        }
        
        return await response.json();
        
    } catch (error) {
        if (error instanceof ValidationError) {
            console.error
            (`Validierungsfehler in Feld ${error.field}: ${error.message}`);
        } else if (error instanceof NetworkError) {
            console.error
            (`Netzwerkfehler (${error.statusCode}): ${error.message}`);
        } else {
            console.error("Unbekannter Fehler:", error);
        }
        throw error; // Re-throw für höhere Ebenen
    }
}

// Global Error Handler
window.addEventListener('error', (event) => {
    console.error('Globaler Fehler:', event.error);
    // Fehler-Logging an Server senden
});

window.addEventListener('unhandledrejection', (event) => {
    console.error('Unbehandelte Promise-Rejection:', event.reason);
    event.preventDefault(); // Verhindert Browser-Konsolen-Ausgabe
});

Defensive Programmierung ergänzt Exception Handling durch präventive Maßnahmen wie Input-Validierung, Null-Checks und Assertions. Diese Techniken reduzieren die Wahrscheinlichkeit von Laufzeitfehlern und verbessern die Robustheit der Anwendung.

Dieses Dokument teilen

Fehlerbehandlung und Exception Handling

Oder Link kopieren

INHALT

Abonnieren

×
Cancel