Regola
Elimina le all'interno dello stesso file duplicazioni evidenti
Codice codice blocchi aumentano onere
onere e il rischio di aggiornamenti aggiornamenti.
Lingue supportate: 45+Introduzione
Il codice copiato e incollato all’interno di un singolo file crea incubi di manutenzione che si aggravano col passare del tempo. Quando la stessa logica compare in più punti, le correzioni di bug e gli aggiornamenti delle funzionalità devono essere applicati a ogni occorrenza. Gli sviluppatori inevitabilmente tralasciano uno dei duplicati, causando un comportamento incoerente in cui la stessa operazione produce risultati diversi a seconda del percorso di codice eseguito. Questa incoerenza è difficile da risolvere perché la logica duplicata sembra identica a prima vista, e le differenze emergono solo dopo un attento confronto.
Perché è importante
Propagazione dei bug: quando un bug è presente in codice duplicato, correggerlo in un punto non significa correggerlo ovunque. Gli sviluppatori risolvono la prima occorrenza senza rendersi conto che esistono copie altrove, lasciando il bug attivo in condizioni diverse.
Onere di manutenzione: ogni blocco duplicato raddoppia i costi di manutenzione. Modificare la logica richiede di individuare e aggiornare ogni copia e, con l'aumentare delle dimensioni dei file, diventa sempre più difficile tenere traccia dei duplicati.
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é è sbagliato: la logica di convalida e il calcolo del totale sono duplicati. Se l'aliquota fiscale cambia o la convalida deve essere migliorata, entrambi i metodi richiedono aggiornamenti. Uno sviluppatore potrebbe aggiornare il calcolo dell'imposta in un metodo ma dimenticarsi dell'altro, causando incongruenze nei prezzi.
✅ 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é è importante: la convalida, il calcolo e la logica fiscale sono centralizzati in singoli metodi. Modificare l’aliquota fiscale significa modificare un solo metodo, senza dover cercare i duplicati in tutto il file. Ogni metodo di supporto può essere testato in modo indipendente, ed entrambi i tipi di ordine ereditano automaticamente eventuali miglioramenti o correzioni di bug.
Conclusione
Le duplicazioni all'interno di un singolo file sono spesso le più facili da correggere e offrono vantaggi immediati. Non appena si individua uno schema ricorrente, è bene estrarre la logica duplicata in funzioni o metodi di supporto. La “regola del tre” suggerisce che, quando un codice ricorre tre volte, è il momento di procedere alla rifattorizzazione. Non bisogna aspettare che la duplicazione si diffonda in tutto il file prima di intervenire.
