Règle

Utilisation précoce retours et garde et les clauses de garde.
L'imbrication imbrication et tardive paramètres tardive
faire fonctions plus difficiles plus lire et de maintenance.

Langues prises en charge : 45+

Introduction

Les clauses de garde valident les conditions préalables au début d'une fonction et renvoient immédiatement si les conditions ne sont pas remplies. Cela permet d'aplanir l'imbrication en traitant les cas d'erreur en amont, en laissant la logique principale non imbriquée et facile à lire. Les fonctions qui valident les paramètres à mi-parcours ou qui imbriquent des chemins de réussite dans plusieurs conditions obligent les lecteurs à suivre le contexte sur plusieurs niveaux d'indentation.

Pourquoi c'est important

Lisibilité du code : Les clauses de garde rendent le chemin heureux visible à la fin de la fonction sans imbrication. Les lecteurs voient d'emblée toutes les conditions d'erreur, puis lisent la logique principale à un seul niveau d'indentation sans avoir à suivre mentalement de multiples conditions imbriquées.

Maintenance et modification : L'ajout de nouvelles conditions de validation ou d'erreur à un code profondément imbriqué nécessite un placement minutieux afin d'éviter d'interrompre la logique existante. Les clauses de garde situées au sommet permettent d'ajouter de nouvelles vérifications sans toucher à la logique principale, ce qui réduit le risque d'introduire des bogues.

Exemples de code

❌ Non conforme :

function processPayment(user, amount) {
    if (user) {
        if (user.isActive) {
            if (amount > 0) {
                if (user.balance >= amount) {
                    user.balance -= amount;
                    return { success: true, newBalance: user.balance };
                } else {
                    return { success: false, error: 'Insufficient funds' };
                }
            } else {
                return { success: false, error: 'Invalid amount' };
            }
        } else {
            return { success: false, error: 'Inactive user' };
        }
    } else {
        return { success: false, error: 'User required' };
    }
}

Pourquoi ce n'est pas correct : Quatre niveaux d'imbrication cachent la logique principale (déduction de l'équilibre) au plus profond de la fonction. Chaque condition d'erreur ajoute un niveau d'indentation supplémentaire, ce qui rend le chemin heureux difficile à trouver et à comprendre au premier coup d'œil.

✅ Conforme :

function processPayment(user, amount) {
    if (!user) {
        return { success: false, error: 'User required' };
    }
    if (!user.isActive) {
        return { success: false, error: 'Inactive user' };
    }
    if (amount <= 0) {
        return { success: false, error: 'Invalid amount' };
    }
    if (user.balance < amount) {
        return { success: false, error: 'Insufficient funds' };
    }

    user.balance -= amount;
    return { success: true, newBalance: user.balance };
}

Pourquoi c'est important : Les clauses de garde valident toutes les conditions préalables avec des retours anticipés, ce qui permet de maintenir la fonction à un seul niveau d'indentation. Le chemin heureux (déduction du solde) est clairement visible à la fin sans imbrication, ce qui rend la fonction facile à lire et à modifier.

Conclusion

Valider les entrées et gérer les cas d'erreur au début des fonctions à l'aide de clauses de garde. Retourner rapidement lorsque les conditions échouent plutôt que d'emboîter le chemin de la réussite. Le code reste ainsi plat, lisible et facile à modifier sans casser la logique existante.