Règle
Éviter l'imbrication imbrication niveaux.
Les niveaux imbrication rend le code difficile difficile lire et difficile à lire et à comprendre.
Langues prises en charge : 45+

Introduction

Un code avec quatre, cinq ou six niveaux d'imbrication crée une charge cognitive qui ralentit le développement. Chaque niveau d'imbrication rend plus difficile le suivi des conditions actives, des chemins d'erreur et de la logique métier. Une imbrication excessive indique souvent un manque d'abstractions ou des opportunités d'utiliser des retours anticipés et des clauses de garde.

Pourquoi c'est important

Maintenabilité du code et risques de bugs : L'imbrication profonde crée du « code flèche » qui repousse la logique hors de l'écran, ralentissant la revue de code. Les développeurs manquent des cas limites lorsqu'ils modifient du code imbriqué car ils ne peuvent pas visualiser toutes les conditions à satisfaire. Des modifications qui semblent correctes isolément peuvent briser des hypothèses établies à plusieurs niveaux supérieurs.

Complexité des tests et du débogage : Chaque niveau d'imbrication double le nombre de cas de test nécessaires pour la couverture, créant une explosion exponentielle des chemins. Les traces de pile (stack traces) des erreurs n'indiquent pas les conditions qui y ont mené, rendant les bugs difficiles à reproduire.

Exemples de code

❌ Non conforme :

function processOrder(order) {
    if (order) {
        if (order.items && order.items.length > 0) {
            if (order.customer) {
                if (order.customer.address) {
                    if (order.paymentMethod) {
                        if (validatePayment(order.paymentMethod)) {
                            return submitOrder(order);
                        }
                    }
                }
            }
        }
    }
    return { error: 'Invalid order' };
}

Pourquoi c'est incorrect : Six niveaux d'imbrication rendent difficile de voir la logique métier réelle (soumission de commande) enfouie au fond. Chaque vérification de condition ajoute une couche d'indentation supplémentaire, et la gestion des erreurs n'est pas claire car il n'y a aucune indication de la validation spécifique qui a échoué.

✅ Conforme :

function processOrder(order) {
    if (!order) {
        return { error: 'Order is required' };
    }

    if (!order.items || order.items.length === 0) {
        return { error: 'Order must contain items' };
    }

    if (!order.customer?.address) {
        return { error: 'Customer address is required' };
    }

    if (!order.paymentMethod || !validatePayment(order.paymentMethod)) {
        return { error: 'Invalid payment method' };
    }

    return submitOrder(order);
}

Pourquoi c'est important : Les clauses de garde avec retours anticipés aplatissent l'imbrication à un seul niveau. Chaque validation est explicite et renvoie un message d'erreur spécifique. Le chemin nominal (soumission de commande) est visible à la fin sans aucune imbrication. Le code est auto-documenté et facile à modifier sans rompre les conditions existantes.

Conclusion

Maintenez les niveaux d'imbrication à trois ou moins chaque fois que possible. Utilisez des retours anticipés, des clauses de garde et des fonctions d'aide pour aplatir les structures profondément imbriquées. Lorsque vous rencontrez une imbrication au-delà de trois niveaux, c'est un signal pour refactoriser en extrayant des méthodes, en inversant les conditions ou en repensant l'approche. Un code plat est plus facile à lire, tester, déboguer et maintenir que les alternatives profondément imbriquées.