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é au sein d'un même fichier engendre des cauchemars de maintenance qui s'aggravent avec le temps. Lorsque la même logique apparaît à plusieurs endroits, les corrections de bugs et les mises à jour de fonctionnalités doivent être appliquées à chaque occurrence. Les développeurs manquent 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 bugs : Lorsqu'un bug existe dans du code dupliqué, le corriger à un endroit ne le corrige pas partout. Les développeurs corrigent la première occurrence sans réaliser que des copies existent ailleurs, laissant le bug actif dans d'autres conditions.

Charge de maintenance : Chaque bloc dupliqué double le coût de maintenance. Modifier la logique nécessite de trouver et de mettre à jour chaque copie, et à mesure que les fichiers augmentent, le suivi des doublons devient plus difficile.

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 incorrect : La logique de validation et le calcul total sont dupliqués. Si le taux de taxe change ou si la validation nécessite une amélioration, les deux méthodes nécessitent des mises à jour. Un développeur pourrait mettre à jour le calcul de la taxe dans une méthode mais oublier l'autre, entraînant une tarification incohérente.

✅ 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 c'est important : La logique de validation, de calcul et de taxation est centralisée dans des méthodes uniques. Modifier le taux d'imposition signifie modifier une seule méthode, plutôt que de chercher des doublons dans le fichier. Chaque méthode d'assistance peut être testée indépendamment, et les deux types de commandes héritent automatiquement de toute amélioration ou correction de bug.

Conclusion

La duplication intra-fichier est souvent la plus facile à corriger et offre des avantages immédiats. Extrayez la logique dupliquée dans des fonctions ou méthodes d'aide dès que vous remarquez le motif. La règle de trois suggère qu'une fois que le code apparaît trois fois, il est temps de refactoriser. N'attendez pas que la duplication se propage dans tout le fichier avant d'y remédier.