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

O código copiado e colado num único ficheiro cria pesadelos de manutenção que se agravam com o tempo. Quando a mesma lógica aparece em vários locais, as correcções de erros e as actualizações de funcionalidades têm de ser aplicadas a todas as ocorrências. Os desenvolvedores inevitavelmente perdem uma das duplicatas, levando a um comportamento inconsistente em que a mesma operação produz resultados diferentes, dependendo do caminho do código 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.

Porque é importante

Propagação de erros: Quando um bug existe em código duplicado, corrigi-lo num local não o corrige em todo o lado. Os programadores corrigem a primeira ocorrência sem se aperceberem que existem cópias noutros locais, deixando o erro ativo em condições diferentes.

Carga de manutenção: Cada bloco duplicado duplica o custo de manutenção. Alterar a lógica exige encontrar e atualizar todas as cópias e, à medida que os ficheiros crescem, torna-se mais difícil localizar os duplicados.

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

Porque é que está errado: A lógica de validação e o cálculo do total são duplicados. Se a taxa de imposto for alterada ou a validação precisar de ser melhorada, ambos os métodos necessitam de actualizações. Um programador pode atualizar o cálculo do imposto num método mas esquecer-se do outro, causando preços inconsistentes.

Conformidade:

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 é importante: A validação, o cálculo e a lógica do imposto são centralizados em métodos únicos. Alterar a taxa de imposto significa modificar um método, e não procurar 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 erros.

Conclusão

A duplicação dentro de um ficheiro é frequentemente a mais fácil de corrigir e proporciona benefícios imediatos. Extraia a lógica duplicada para funções ou métodos auxiliares assim que notar o padrão. A regra de três sugere que quando o código aparece três vezes, é altura de refactorizar. Não espere que a duplicação se espalhe por todo o ficheiro antes de a resolver.