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 comportant 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 d'entreprise. Une imbrication excessive indique souvent des abstractions manquantes ou des possibilités d'utiliser des retours anticipés et des clauses de garde.

Pourquoi c'est important

Maintenabilité du code et risques de bogues : L'imbrication profonde crée un "code flèche" qui repousse la logique hors de l'écran, ce qui ralentit la révision du code. Les développeurs ne voient pas les cas limites lorsqu'ils modifient le code imbriqué parce qu'ils ne peuvent pas voir toutes les conditions qui doivent être remplies. Des modifications qui semblent correctes de manière isolée peuvent rompre des hypothèses formulées à plusieurs niveaux.

Complexité des tests et du débogage : Chaque niveau d'imbrication double les cas de test nécessaires à la couverture, ce qui crée une explosion exponentielle des chemins. Les traces de pile des erreurs ne montrent pas quelles conditions ont conduit à ces erreurs, ce qui rend les bogues 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 ce n'est pas correct : six niveaux d'imbrication empêchent de voir la logique commerciale réelle (soumission de la commande) enfouie en bas. Chaque vérification de condition ajoute une nouvelle couche d'indentation, et la gestion des erreurs n'est pas claire car rien n'indique quelle validation spécifique 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 cela est-il important ? Les clauses de garde avec retour anticipé ramènent l'imbrication à un seul niveau. Chaque validation est explicite et renvoie un message d'erreur spécifique. Le chemin heureux (soumission de la commande) est visible à la fin sans aucune imbrication. Le code est auto-documenté et facile à modifier sans rompre les conditions existantes.

Conclusion

Limitez autant que possible les niveaux d'imbrication à trois ou moins. Utilisez les retours anticipés, les clauses de garde et les fonctions d'aide pour aplatir les structures profondément imbriquées. Lorsque vous rencontrez une imbrication à plus de trois niveaux, c'est le signal qu'il faut refondre en extrayant des méthodes, en inversant des conditions ou en repensant l'approche. Un code plat est plus facile à lire, à tester, à déboguer et à maintenir qu'un code profondément imbriqué.