Regola
Elimina la duplicazione evidente all'interno dello stesso file.
I blocchi di codice duplicato aumentano l'onere
di manutenzione e il rischio di aggiornamenti incoerenti.
Linguaggi supportati: 45+Introduzione
Il codice copiato e incollato all'interno di un singolo file crea problemi di manutenzione che si aggravano nel tempo. Quando la stessa logica compare in più punti, la correzione dei bug e l'aggiornamento delle funzionalità devono essere applicati a ogni singola occorrenza. È inevitabile che gli sviluppatori dimentichino uno dei duplicati, generando un comportamento incoerente in cui la stessa operazione produce risultati diversi a seconda del percorso di esecuzione del codice. Questa incoerenza è difficile da sottoporre a debug perché a prima vista la logica duplicata sembra identica e le differenze emergono solo dopo un'attenta analisi.
Perché è importante
Propagazione dei bug: Se è presente un bug nel codice duplicato, correggerlo in un punto non significa risolverlo ovunque. Gli sviluppatori spesso correggono la prima occorrenza senza rendersi conto che ne esistono copie altrove, lasciando il bug attivo in condizioni differenti.
Onere di manutenzione: Ciascun blocco duplicato raddoppia i costi di manutenzione. Modificare la logica richiede di individuare e aggiornare ogni copia e, man mano che i file crescono, il tracciamento dei duplicati diventa più complesso.
Esempi di codice
❌ Non 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 };
}
}Perché è errato: La logica di convalida e il calcolo del totale sono duplicati. Se l'aliquota fiscale cambia o la convalida richiede miglioramenti, entrambi i metodi devono essere aggiornati. Uno sviluppatore potrebbe aggiornare il calcolo delle tasse in un metodo dimenticandosi dell'altro, causando così prezzi incoerenti.
✅ 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 };
}
}Perché questo è importante: La logica di convalida, calcolo e gestione delle tasse è centralizzata in singoli metodi. Modificare l'aliquota fiscale significa modificare un solo metodo, senza dover cercare duplicati in tutto il file. Ciascun metodo di supporto può essere testato indipendentemente e tutti i tipi di ordine ereditano automaticamente eventuali miglioramenti o correzioni di bug.
Conclusione
La duplicazione all'interno dello stesso file è spesso la più semplice da risolvere e offre vantaggi immediati. Estrai la logica duplicata in funzioni o metodi di supporto non appena noti il pattern. La regola del tre suggerisce che, quando un blocco di codice compare tre volte, è il momento di effettuare il refactoring. Non aspettare che la duplicazione si diffonda nell'intero file prima di intervenire.
