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+

Einführung

Kopierter Code in einer einzigen Datei verursacht Wartungsalpträume, die sich mit der Zeit häufen. Wenn dieselbe Logik an mehreren Stellen auftaucht, müssen Fehlerbehebungen und Funktionsaktualisierungen auf jedes Vorkommen angewendet werden. Die Entwickler übersehen unweigerlich eines der Duplikate, was zu einem inkonsistenten Verhalten führt, bei dem derselbe Vorgang unterschiedliche Ergebnisse liefert, je nachdem, welcher Codepfad ausgeführt wird. Diese Inkonsistenz ist schwer zu beheben, da die duplizierte Logik auf den ersten Blick identisch aussieht und die Unterschiede erst nach einem sorgfältigen Vergleich sichtbar werden.

Warum das wichtig ist

Fehlerfortpflanzung: Wenn ein Fehler in dupliziertem Code vorhanden ist, führt die Behebung an einer Stelle nicht dazu, dass er überall behoben wird. Die Entwickler beheben das erste Vorkommen, ohne zu bemerken, dass an anderer Stelle Kopien existieren und der Fehler unter anderen Bedingungen aktiv bleibt.

Wartungsaufwand: Jeder duplizierte Block verdoppelt die Wartungskosten. Eine Änderung der Logik erfordert das Auffinden und Aktualisieren jeder Kopie, und je größer die Dateien werden, desto schwieriger wird es, Duplikate zu finden.

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 ist das falsch: Die Validierungslogik und die Gesamtberechnung sind doppelt vorhanden. Wenn sich der Steuersatz ändert oder die Validierung erweitert werden muss, müssen beide Methoden aktualisiert werden. Ein Entwickler könnte die Steuerberechnung in einer Methode aktualisieren, aber die andere vergessen, was zu einer inkonsistenten Preisgestaltung 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: Validierung, Berechnung und Steuerlogik sind in einzelnen Methoden zentralisiert. Wenn Sie den Steuersatz ändern, müssen Sie nur eine Methode ändern und nicht in der Datei nach Duplikaten suchen. Jede Hilfsmethode kann unabhängig getestet werden, und beide Auftragstypen erben automatisch alle Verbesserungen oder Fehlerbehebungen.

Schlussfolgerung

Duplizierung innerhalb einer Datei ist oft am einfachsten zu beheben und bietet sofortige Vorteile. Extrahieren Sie duplizierte Logik in Hilfsfunktionen oder -methoden, sobald Sie das Muster bemerken. Die Dreierregel besagt, dass es Zeit für ein Refactoring ist, sobald der Code dreimal vorkommt. Warten Sie nicht darauf, dass sich die Duplikation über die gesamte Datei ausbreitet, bevor Sie sich damit befassen.