Regla
Elimine obvio dentro del archivo dentro de un archivo.
Duplicado código bloques aumentan mantenimiento
mantenimiento y el riesgo de inconsistentes inconsistentes.
Idiomas compatibles: 45+

Introducción

El código copiado y pegado dentro de un mismo archivo crea pesadillas de mantenimiento que se agravan con el tiempo. Cuando la misma lógica aparece en varios lugares, las correcciones de errores y las actualizaciones de funciones deben aplicarse a cada caso. Inevitablemente, los desarrolladores pasan por alto uno de los duplicados, lo que provoca un comportamiento incoherente en el que la misma operación produce resultados diferentes en función de la ruta de código que se ejecute. Esta incoherencia es difícil de depurar porque la lógica duplicada parece idéntica a primera vista, y las diferencias sólo surgen tras una cuidadosa comparación.

Por qué es importante

Propagación de errores: Cuando un fallo existe en código duplicado, arreglarlo en un sitio no lo arregla en todos. Los desarrolladores arreglan la primera incidencia sin darse cuenta de que existen copias en otros lugares, lo que deja el fallo activo en condiciones diferentes.

Carga de mantenimiento: Cada bloque duplicado duplica el coste de mantenimiento. Cambiar la lógica requiere encontrar y actualizar cada copia, y a medida que crecen los archivos, el seguimiento de los duplicados se hace más difícil.

Ejemplos de códigos

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

Por qué es incorrecto: La lógica de validación y el cálculo del total están duplicados. Si el tipo impositivo cambia o la validación necesita una mejora, ambos métodos requieren actualizaciones. Un desarrollador podría actualizar el cálculo de impuestos en un método pero olvidarse del otro, causando precios inconsistentes.

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

Por qué es importante: La validación, el cálculo y la lógica fiscal están centralizados en métodos únicos. Cambiar el tipo impositivo significa modificar un método, no buscar duplicados en el archivo. Cada método de ayuda se puede probar de forma independiente, y ambos tipos de pedido heredan automáticamente cualquier mejora o corrección de errores.

Conclusión

La duplicación dentro de un archivo suele ser la más fácil de solucionar y proporciona beneficios inmediatos. Extraiga la lógica duplicada en funciones o métodos de ayuda en cuanto detecte el patrón. La regla de tres sugiere que una vez que el código aparece tres veces, es hora de refactorizar. No espere a que la duplicación se extienda por todo el archivo antes de abordarla.