Regel
Beseitigen Sie Offensichtlich innerhalb einer Datei Duplikate.
Duplizierte Code Blöcke erhöhen Wartung
Aufwand und das Risiko von inkonsistenten Aktualisierungen.
Unterstützte Sprachen: 45+

Einleitung

Kopierter Code innerhalb einer einzelnen Datei führt zu Wartungsalpträumen, die sich mit der Zeit verstärken. Wenn dieselbe Logik an mehreren Stellen auftaucht, müssen Fehlerbehebungen und Feature-Updates auf jedes Vorkommen angewendet werden. Entwickelnde übersehen unweigerlich eines der Duplikate, was zu inkonsistentem Verhalten führt, bei dem dieselbe Operation je nach ausgeführtem Codepfad unterschiedliche Ergebnisse liefert. Diese Inkonsistenz ist schwer zu debuggen, da die duplizierte Logik auf den ersten Blick identisch aussieht und Unterschiede erst nach sorgfältigem Vergleich sichtbar werden.

Warum es wichtig ist

Fehlerfortpflanzung: Wenn ein Fehler in dupliziertem Code existiert, behebt ihn die Korrektur an einer Stelle nicht überall. Entwickelnde beheben das erste Vorkommen, ohne zu merken, dass Kopien an anderer Stelle existieren, wodurch der Fehler unter anderen Bedingungen aktiv bleibt.

Wartungsaufwand: Jeder duplizierte Block verdoppelt die Wartungskosten. Das Ändern der Logik erfordert das Auffinden und Aktualisieren jeder Kopie, und mit zunehmender Dateigröße wird das Verfolgen von Duplikaten schwieriger.

Code-Beispiele

❌ Nicht konform:

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 };
    }
}

Warum es falsch ist: Die Validierungslogik und die Gesamtberechnung sind dupliziert. Wenn sich der Steuersatz ändert oder die Validierung verbessert werden muss, müssen beide Methoden aktualisiert werden. Ein Entwickelnde könnte die Steuerberechnung in einer Methode aktualisieren, aber die andere vergessen, was zu inkonsistenten Preisen führt.

✅ Konform:

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 };
    }
}

Warum das wichtig ist: Validierungs-, Berechnungs- und Steuerlogik sind in einzelnen Methoden zentralisiert. Eine Änderung des Steuersatzes bedeutet die Modifikation einer Methode, nicht das Durchsuchen der Datei nach Duplikaten. Jede Hilfsmethode kann unabhängig getestet werden, und beide Auftragstypen erben automatisch alle Verbesserungen oder Fehlerbehebungen.

Fazit

Dateieninterne Duplikation ist oft am einfachsten zu beheben und bietet sofortige Vorteile. Extrahieren Sie duplizierte Logik in Hilfsfunktionen oder -methoden, sobald Sie das Muster erkennen. Die Dreierregel besagt, dass es Zeit für ein Refactoring ist, sobald Code dreimal auftaucht. Warten Sie nicht, bis sich die Duplikation über die gesamte Datei ausgebreitet hat, bevor Sie sie beheben.