Regra
Eliminar óbvio dentro do ficheiro duplicação.
O código código blocos aumentam a manutenção
manutenção e o risco de incoerência actualizações inconsistentes.
Idiomas suportados: 45+

Introdução

Código copiado e colado dentro de um único arquivo cria pesadelos de manutenção que se agravam com o tempo. Quando a mesma lógica aparece em vários lugares, correções de bugs e atualizações de recursos devem ser aplicadas a todas as ocorrências. Os desenvolvedores inevitavelmente perdem um dos duplicados, levando a um comportamento inconsistente onde a mesma operação produz resultados diferentes dependendo do caminho de código que é executado. Essa inconsistência é difícil de depurar porque a lógica duplicada parece idêntica à primeira vista, e as diferenças só surgem após uma comparação cuidadosa.

Por que isso importa

Propagação de bug: Quando um bug existe em código duplicado, corrigi-lo em um local não o corrige em todos os lugares. Desenvolvedores corrigem a primeira ocorrência sem perceber que cópias existem em outros lugares, deixando o bug ativo sob diferentes condições.

Carga de manutenção: Cada bloco duplicado dobra o custo de manutenção. Alterar a lógica requer encontrar e atualizar cada cópia, e à medida que os arquivos crescem, rastrear duplicatas se torna mais difícil.

Exemplos de código

❌ Não-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 que está errado: A lógica de validação e o cálculo total são duplicados. Se a taxa de imposto mudar ou a validação precisar de aprimoramento, ambos os métodos exigirão atualizações. Um desenvolvedor pode atualizar o cálculo do imposto em um método, mas esquecer o outro, causando preços inconsistentes.

✅ Compatível:

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 que isso importa: A lógica de validação, cálculo e impostos é centralizada em métodos únicos. Alterar a alíquota de imposto significa modificar um único método, e não procurar por duplicatas no arquivo. Cada método auxiliar pode ser testado independentemente, e ambos os tipos de pedido herdam automaticamente quaisquer melhorias ou correções de bugs.

Conclusão

A duplicação dentro do arquivo é frequentemente a mais fácil de corrigir e oferece benefícios imediatos. Extraia a lógica duplicada para funções ou métodos auxiliares assim que você notar o padrão. A regra dos três sugere que, uma vez que o código aparece três vezes, é hora de refatorar. Não espere que a duplicação se espalhe por todo o arquivo antes de abordá-la.