Règle
Éliminer évidentes à l'intérieur d'un à l'intérieur d'un même fichier.
Le code code blocs augmentent la maintenance
maintenance et et le risque de incohérentes. incohérentes.
Langues prises en charge : 45+

Introduction

Le code copié-collé dans un seul fichier crée des cauchemars de maintenance qui s'aggravent avec le temps. Lorsque la même logique apparaît à plusieurs endroits, les corrections de bogues et les mises à jour de fonctionnalités doivent être appliquées à chaque occurrence. Les développeurs oublient inévitablement l'un des doublons, ce qui entraîne un comportement incohérent où la même opération produit des résultats différents selon le chemin de code exécuté. Cette incohérence est difficile à déboguer car la logique dupliquée semble identique à première vue, et les différences n'apparaissent qu'après une comparaison minutieuse.

Pourquoi c'est important

Propagation des bogues : Lorsqu'un bogue existe dans un code dupliqué, le fait de le corriger à un endroit ne le corrige pas partout. Les développeurs corrigent la première occurrence sans se rendre compte que des copies existent ailleurs, laissant le bogue actif dans d'autres conditions.

Charge de maintenance : Chaque bloc dupliqué double les coûts de maintenance. Pour modifier la logique, il faut trouver et mettre à jour chaque copie et, au fur et à mesure que les fichiers augmentent, il devient plus difficile de repérer les doublons.

Exemples de code

❌ Non conforme :

class OrderProcessor {
    async processStandardOrder(order) {
        if (!order.items || order.items.length === 0) {
            throw new Error('Order must have items');
        }
        const total = order.items.reduce((sum, item) => 
            sum + (item.price * item.quantity), 0);
        const tax = total * 0.08;
        const finalAmount = total + tax;
        return { total: finalAmount, tax };
    }
    
    async processExpressOrder(order) {
        if (!order.items || order.items.length === 0) {
            throw new Error('Order must have items');
        }
        const total = order.items.reduce((sum, item) => 
            sum + (item.price * item.quantity), 0);
        const tax = total * 0.08;
        const expressfee = 15.99;
        const finalAmount = total + tax + expressFee;
        return { total: finalAmount, tax, expressFee };
    }
}

Pourquoi c'est faux : la logique de validation et le calcul du total sont dupliqués. Si le taux d'imposition change ou si la validation doit être améliorée, les deux méthodes doivent être mises à jour. Un développeur peut mettre à jour le calcul de la taxe dans une méthode mais oublier l'autre, ce qui entraîne des incohérences dans la tarification.

✅ Conforme :

class OrderProcessor {
    validateOrder(order) {
        if (!order.items || order.items.length === 0) {
            throw new Error('Order must have items');
        }
    }
    
    calculateSubtotal(items) {
        return items.reduce((sum, item) => 
            sum + (item.price * item.quantity), 0);
    }
    
    calculateTax(amount) {
        return amount * 0.08;
    }
    
    async processStandardOrder(order) {
        this.validateOrder(order);
        const subtotal = this.calculateSubtotal(order.items);
        const tax = this.calculateTax(subtotal);
        return { total: subtotal + tax, tax };
    }
    
    async processExpressOrder(order) {
        this.validateOrder(order);
        const subtotal = this.calculateSubtotal(order.items);
        const tax = this.calculateTax(subtotal);
        const expressFee = 15.99;
        return { total: subtotal + tax + expressFee, tax, expressFee };
    }
}

Pourquoi cela est-il important ? La validation, le calcul et la logique fiscale sont centralisés dans des méthodes uniques. Modifier le taux d'imposition revient à modifier une seule méthode, et non à rechercher des doublons dans le fichier. Chaque méthode d'aide peut être testée indépendamment, et les deux types de commandes héritent automatiquement de toutes les améliorations ou corrections de bogues.

Conclusion

La duplication à l'intérieur d'un fichier est souvent la plus facile à corriger et offre des avantages immédiats. Extrayez la logique dupliquée dans des fonctions ou des méthodes d'aide dès que vous remarquez le schéma. La règle des trois suggère qu'une fois que le code apparaît trois fois, il est temps de le remanier. N'attendez pas que la duplication s'étende à l'ensemble du fichier pour vous en occuper.