Fehlerbehandlung ist ein entscheidender Aspekt beim Schreiben robuster und zuverlässiger Software. Wenn Sie jedoch nicht sorgfältig vorgehen, kann dies zu unübersichtlichem Code führen, der schwer zu lesen und zu warten ist.

Kapitel 7 von Clean Code befasst sich mit Techniken zum Umgang mit Fehlern, die Ihren Code nicht überladen, und legt Wert auf Klarheit und Einfachheit.

In diesem Artikel untersuchen wir die Schlüsselkonzepte aus diesem Kapitel und wie Sie sie in JavaScript anwenden, um Ihre Codebasis sauber und wartbar zu halten.

? 1. Verwenden Sie Ausnahmen anstelle von Fehlercodes

Eines der Grundprinzipien von Clean Code besteht darin, Ausnahmen gegenüber Fehlercodes zu bevorzugen.

Mit Ausnahmen können Sie die Fehlerbehandlungslogik von Ihrer Hauptlogik trennen und so Ihren Code besser lesbar machen.

Beispiel: Fehlercodes vermeiden

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        return -1;  // Error code for user not found
    }
    return user;
}

const result = getUser(123);
if (result === -1) {
    console.error('User not found');
} else {
    console.log(result);
}

In diesem Beispiel ist die Fehlerbehandlung mit der Hauptlogik verflochten, was es schwieriger macht, ihr zu folgen.

Beispiel: Ausnahmen verwenden

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error('User not found');
    }
    return user;
}

try {
    const user = getUser(123);
    console.log(user);
} catch (error) {
    console.error(error.message);
}

Durch die Verwendung von Ausnahmen trennen wir die Fehlerbehandlungslogik von der Hauptlogik, wodurch der Code sauberer und verständlicher wird.

? 2. Stellen Sie Kontext mit aussagekräftigen Nachrichten bereit

Beim Auslösen von Ausnahmen ist es wichtig, aussagekräftige Fehlermeldungen bereitzustellen, die den Kontext zum Fehler angeben.

Dies hilft bei der schnellen Diagnose von Problemen, ohne dass man sich in den Code vertiefen muss.

Beispiel: Kontext in Fehlermeldungen bereitstellen

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error(`User with ID ${id} not found`);
    }
    return user;
}

try {
    const user = getUser(123);
    console.log(user);
} catch (error) {
    console.error(error.message);  // Outputs: User with ID 123 not found
}

Eine beschreibende Fehlermeldung liefert den Kontext, der zum sofortigen Verständnis des Problems erforderlich ist.

? 3. Geben Sie nicht Null zurück

Die Rückgabe von null kann zu schwer nachvollziehbaren Nullreferenzfehlern führen.

Anstatt null zurückzugeben, sollten Sie erwägen, eine Ausnahme auszulösen oder ein Sonderfallmuster zu verwenden, das ein Standardverhalten bereitstellt.

Beispiel: Vermeiden Sie die Rückgabe von Null

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        return null;  // This can lead to null reference errors
    }
    return user;
}

const user = getUser(123);
if (user !== null) {
    console.log(user.name);
}

Die Rückgabe von Null erfordert zusätzliche Prüfungen und kann Ihren Code überladen.

Beispiel: Eine Ausnahme auslösen oder einen Sonderfall verwenden

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error(`User with ID ${id} not found`);
    }
    return user;
}

// OR

class NullUser {
    get name() {
        return 'Guest';
    }
}

function getUser(id) {
    const user = database.findUserById(id);
    return user || new NullUser();
}

Das Auslösen einer Ausnahme oder die Verwendung eines Sonderfallobjekts (wie NullUser) hilft, Nullreferenzfehler zu vermeiden und Ihren Code sauber zu halten.

? 4. Gehen Sie mit Try-Catch-Finally sparsam um

Während try-catch-finally-Blöcke für die Behandlung von Ausnahmen unerlässlich sind, kann ihre übermäßige Verwendung Ihren Code überladen.

Verwenden Sie sie nur bei Bedarf und vermeiden Sie tief verschachtelte Blöcke.

Beispiel: Vermeiden Sie übermäßiges Try-Catch

try {
    const data = JSON.parse(input);
    try {
        const user = getUser(data.id);
        try {
            sendEmail(user.email);
        } catch (error) {
            console.error('Failed to send email:', error.message);
        }
    } catch (error) {
        console.error('User retrieval failed:', error.message);
    }
} catch (error) {
    console.error('Invalid JSON:', error.message);
}

Diesem Code ist aufgrund mehrerer verschachtelter Try-Catch-Blöcke schwer zu folgen.

Beispiel: Refactor zur Reduzierung von Unordnung

function parseInput(input) {
    try {
        return JSON.parse(input);
    } catch (error) {
        throw new Error('Invalid JSON');
    }
}

function retrieveUser(data) {
    return getUser(data.id);
}

function notifyUser(user) {
    sendEmail(user.email);
}

try {
    const data = parseInput(input);
    const user = retrieveUser(data);
    notifyUser(user);
} catch (error) {
    console.error(error.message);
}

Durch die Aufteilung der Logik in separate Funktionen reduzieren wir die Verschachtelung und verbessern die Lesbarkeit.

? 5. Ignorieren Sie abgefangene Ausnahmen nicht

Wenn Sie eine Ausnahme abfangen, stellen Sie sicher, dass Sie diese ordnungsgemäß behandeln.

Das stille Ignorieren von Ausnahmen kann zu unerwartetem Verhalten führen und das Debuggen erschweren.

Beispiel: Ausnahmen nicht ignorieren

try {
    const user = getUser(123);
} catch (error) {
    // Ignoring the exception
}

Das Ignorieren von Ausnahmen kann potenzielle Probleme in Ihrem Code verschleiern.

Beispiel: Ausnahme behandeln oder protokollieren

try {
    const user = getUser(123);
} catch (error) {
    console.error('An error occurred:', error.message);
}

Durch die Behandlung oder Protokollierung der Ausnahme wird sichergestellt, dass Sie über alle Probleme informiert sind und diese entsprechend beheben können.

⚡ Fazit

Eine effektive Fehlerbehandlung ist für das Schreiben von sauberem, wartbarem JavaScript-Code unerlässlich.

Indem Sie die Prinzipien von Clean Code befolgen – z. B. Ausnahmen anstelle von Fehlercodes verwenden, Kontext in Fehlermeldungen bereitstellen, Null-Returns vermeiden, Try-Catch sparsam verwenden und abgefangene Ausnahmen nicht ignorieren – können Sie sicherstellen, dass Ihre Fehlerbehandlungslogik ist sowohl robust als auch unauffällig.

Viel Spaß beim Codieren!