La gestion des erreurs est un aspect crucial de l'écriture d'un logiciel robuste et fiable. Cependant, ne pas être fait avec soin peut conduire à un code encombré, difficile à lire et à maintenir.

Le chapitre 7 de Clean Code aborde les techniques de gestion des erreurs qui n'encombrent pas votre code, en mettant l'accent sur la clarté et la simplicité.

Dans cet article, nous explorerons les concepts clés de ce chapitre et comment les appliquer en JavaScript pour garder votre base de code propre et maintenable.

? 1. Utilisez des exceptions plutôt que des codes d'erreur

L'un des principes clés de Clean Code est de préférer les exceptions aux codes d'erreur.

Les exceptions vous permettent de séparer la logique de gestion des erreurs de votre logique principale, rendant ainsi votre code plus lisible.

Exemple : Éviter les codes d'erreur

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

Dans cet exemple, la gestion des erreurs est étroitement liée à la logique principale, ce qui la rend plus difficile à suivre.

Exemple : Utiliser des exceptions

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

En utilisant des exceptions, nous séparons la logique de gestion des erreurs de la logique principale, ce qui rend le code plus propre et plus facile à comprendre.

? 2. Fournissez du contexte avec des messages significatifs

Lors du lancement d'exceptions, il est important de fournir des messages d'erreur significatifs qui donnent le contexte de l'erreur.

Cela permet de diagnostiquer rapidement les problèmes sans avoir à fouiller dans le code.

Exemple : fournir du contexte dans les messages d'erreur

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
}

Un message d'erreur descriptif fournit le contexte nécessaire pour comprendre immédiatement le problème.

? 3. Ne retournez pas null

Le retour de null peut entraîner des erreurs de référence null difficiles à retracer.

Au lieu de renvoyer null, envisagez de lever une exception ou d'utiliser un modèle de cas spécial qui fournit un comportement par défaut.

Exemple : éviter de renvoyer 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);
}

Le retour de null nécessite des vérifications supplémentaires et peut encombrer votre code.

Exemple : lancer une exception ou utiliser un cas spécial

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();
}

Lancer une exception ou utiliser un objet de cas spécial (comme NullUser) permet d'éviter les erreurs de référence nulle et de garder votre code propre.

? 4. Utilisez Try-Catch-Finally avec parcimonie

Bien que les blocs try-catch-finally soient essentiels pour gérer les exceptions, leur utilisation excessive peut encombrer votre code.

Utilisez-les uniquement lorsque cela est nécessaire et évitez les blocs profondément imbriqués.

Exemple : éviter les tentatives excessives de capture

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

Ce code est difficile à suivre en raison de plusieurs blocs try-catch imbriqués.

Exemple : Refactoriser pour réduire l'encombrement

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

En décomposant la logique en fonctions distinctes, nous réduisons l'imbrication et améliorons la lisibilité.

? 5. N'ignorez pas les exceptions détectées

Si vous détectez une exception, assurez-vous de la gérer correctement.

Ignorer silencieusement les exceptions peut entraîner un comportement inattendu et rendre le débogage difficile.

Exemple : Ne pas ignorer les exceptions

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

Ignorer les exceptions peut masquer des problèmes potentiels dans votre code.

Exemple : Gérer ou enregistrer l'exception

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

La gestion ou la journalisation de l'exception garantit que vous êtes au courant de tout problème et que vous pouvez les résoudre en conséquence.

⚡Conclusion

Une gestion efficace des erreurs est essentielle pour écrire du code JavaScript propre et maintenable.

En suivant les principes de Clean Code, tels que l'utilisation d'exceptions au lieu de codes d'erreur, la fourniture de contexte dans les messages d'erreur, l'évitement des retours nuls, l'utilisation de try-catch avec parcimonie et le fait de ne pas ignorer les exceptions interceptées, vous pouvez garantir que votre logique de gestion des erreurs est à la fois robuste et discret.

Joyeux codage !