Clean Code verstehen: Handhabung ⚡

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 zur Fehlerbehandlung, 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.

Ausnahmen ermöglichen es Ihnen, die Fehlerbehandlungslogik von Ihrer Hauptlogik zu trennen und so Ihren Code besser lesbar zu 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 leichter verständlich 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: Geben Sie Kontext in Fehlermeldungen an

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 Nullreferenzfehlern führen, die schwer nachzuverfolgen sind.

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: Refaktorierung 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);
}

Indem wir die Logik in separate Funktionen aufteilen, 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: Behandeln oder protokollieren Sie die Ausnahme

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 etwaige 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 funktioniert ist sowohl robust als auch unauffällig.

Viel Spaß beim Programmieren!

Das obige ist der detaillierte Inhalt vonClean Code verstehen: Handhabung ⚡. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!