Clean Code

Le clean code consiste à écrire du code clair, lisible et facile à maintenir.

Un code propre n’est pas seulement un code qui fonctionne. C’est un code qu’on peut comprendre, modifier, tester et améliorer facilement.

L’objectif est de réduire la complexité.

1. Pourquoi écrire du clean code

Un projet évolue constamment. Plus le code est clair, plus il est facile à modifier sans créer de bugs.

Le clean code aide à :

• Lire le code plus rapidement
• Corriger les erreurs plus facilement
• Ajouter de nouvelles fonctionnalités
• Travailler en équipe
• Tester le code plus simplement

2. Éviter l’imbrication excessive

Plus un code est imbriqué, plus il devient difficile à lire.

if (isLoggedIn) {

    if (isAdmin) {

        console.log("Accès admin");

    }

}

Ici, le code fonctionne, mais il commence déjà à être imbriqué.

3. Early return

Un early return consiste à quitter une fonction rapidement lorsqu’un cas invalide est détecté.

function accessAdmin(user) {

    if (!user) {

        return;

    }

    if (!user.isAdmin) {

        return;

    }

    console.log("Accès admin");

}

Le code principal reste plus plat et plus lisible.

4. Guard clause

Une guard clause est une condition placée au début d’une fonction pour gérer un cas invalide.

function checkout(cart) {

    if (cart.size === 0) {

        return "Votre panier est vide";

    }

    return "Commande validée";

}

On gère d’abord les exceptions, puis on laisse le cas normal respirer.

5. Le happy path

Le happy path représente le déroulement normal du programme.

En clean code, on essaie de garder ce chemin principal le moins imbriqué possible.

function getMessage(user) {

    if (!user) {

        return "Utilisateur invalide";

    }

    return `Bonjour ${user.name}`;

}

6. Supprimer les else inutiles

Lorsqu’un bloc contient déjà un return, le else devient souvent inutile.

function getStatus(isLoggedIn) {

    if (!isLoggedIn) {

        return "Déconnecté";

    }

    return "Connecté";

}

Le return arrête déjà la fonction. Il n’est donc pas nécessaire d’ajouter un else.

7. Éviter les variables mutables inutiles

Une variable déclarée avec let peut être modifiée. Mais si ce n’est pas nécessaire, mieux vaut utiliser const.

// Moins propre

let message;

if (isLoggedIn) {

    message = "Bienvenue";

} else {

    message = "Connexion requise";

}

Une meilleure approche consiste à isoler la logique dans une fonction.

function getMessage(isLoggedIn) {

    if (isLoggedIn) {

        return "Bienvenue";

    }

    return "Connexion requise";

}

const message = getMessage(isLoggedIn);

8. Préférer les fonctions pures

Une fonction pure retourne toujours le même résultat avec les mêmes arguments.

function add(a, b) {

    return a + b;

}

Les fonctions pures sont plus simples à tester, à comprendre et à déboguer.

9. Éviter les effets de bord inutiles

Un effet de bord se produit lorsqu’une fonction modifie quelque chose à l’extérieur d’elle-même.

let total = 0;

function addToTotal(price) {

    total = total + price;

}

Cette fonction dépend d’une variable externe. Elle est donc plus difficile à tester.

Version plus propre :

function add(price, total) {

    return total + price;

}

10. Une fonction = une responsabilité

Une fonction devrait faire une seule chose.

function calculateTotal(price, tax) {

    return price + tax;

}

Si une fonction fait trop de choses, elle devient difficile à lire, tester et modifier.

11. Noms clairs

Un nom doit expliquer l’intention du code.

// Moins clair

const x = 100;

function calc() {

}

// Plus clair

const totalPrice = 100;

function calculateTotal() {

}

Un bon nom réduit le besoin de commentaires.

12. Tester les cas invalides en premier

En clean code, on place souvent les cas invalides au début.

function processUsername(username) {

    if (!username) {

        return "Nom invalide";

    }

    if (username.length < 3) {

        return "Nom trop court";

    }

    return "Nom valide";

}

Cette structure rend le code plus facile à suivre.

13. Éviter la duplication

Répéter le même code plusieurs fois augmente les risques d’erreur.

function displayError(message) {

    console.log("Erreur : " + message);

}

Une fonction réutilisable permet de centraliser la logique.

14. Code plat vs code imbriqué

15. Formule mentale

Gérer les cas invalides
↓
Retourner tôt
↓
Garder le cas normal clair

Cette mentalité aide à écrire du code plus propre.

16. Bonnes pratiques

• Utiliser const par défaut
• Éviter les else inutiles
• Utiliser des early returns
• Tester les cas invalides en premier
• Créer des fonctions courtes
• Donner des noms clairs
• Éviter la duplication
• Limiter les effets de bord
• Préférer les fonctions pures

Résumé rapide