Come disciplinare il codice con il refactoring (include esempi PHP)

Pubblicato: 2021-06-22

Come molte altre cose nella vita, anche il nostro codice ha bisogno di disciplina. Sono abbastanza sicuro che nessuno sviluppatore al mondo voglia scrivere codice sporco. Tuttavia, il codice non pulito esiste ancora. Può sorgere a causa di vari motivi: può essere dovuto alla pressione aziendale, alla mancanza di documentazione, alla mancanza di interazione tra i membri del team o all'incompetenza dello sviluppatore. È necessario intraprendere le dovute azioni per rendere il codice più pulito ed evitare problemi che potrebbero verificarsi in futuro a causa di ciò. Fortunatamente, possiamo affrontare questi problemi con una tecnica disciplinata per ristrutturare il codice chiamato Refactoring .

Il refactoring è una tecnica per migliorare la struttura interna del codice sorgente del programma esistente e mantenerne il comportamento esterno. È una procedura passo passo per migliorare il codice, che altrimenti ci costerà molto tempo e fatica.

Refactoring del codice

Svantaggi del codice impuro

L'espansione della dimensione del codice sorgente aggiungendo nuovi programmi senza effettuare il refactoring per lungo tempo rende il codice disordinato e sporco. Rende molto difficile la manutenzione e l'ulteriore sviluppo del progetto. Il codice sporco presenta moltissimi svantaggi:

  1. Aumenta i costi di manutenzione del progetto.
  2. L'aggiunta di nuove funzionalità richiede molto tempo e talvolta diventa impossibile aggiungerle.
  3. Rallenta l'introduzione di nuove persone nel progetto.
  4. Contiene codice duplicato.
  5. Non supera tutti i test.

Ci sono molti altri svantaggi, ma questi problemi costano molto tempo e denaro all'organizzazione.

Vantaggi del codice pulito

Il codice pulito e disciplinato ha i suoi vantaggi:

  1. Non contiene codice duplicato.
  2. Supera tutti i test.
  3. Rende il codice più leggibile e più facile da comprendere.
  4. Rende il codice più facile da mantenere e meno costoso.

I vantaggi del codice pulito sono molti. Il processo di trasformazione di un codice sporco e disordinato in un codice pulito più gestibile è chiamato processo di refactoring.

Processo di refactoring

Il refactoring dovrebbe essere eseguito come una serie di piccole modifiche, ognuna delle quali migliora leggermente il codice esistente e consente al programma di continuare a funzionare senza romperlo. Dopo il refactoring, il codice dovrebbe diventare più pulito di prima. Se rimane impuro, allora non c'è motivo di refactoring. È solo una perdita di tempo e fatica. Nessun nuovo codice deve essere aggiunto durante il refactoring per creare nuove funzionalità. Dovrebbe superare tutti i test dopo il refactoring.

Quando effettuare il refactoring?

Il refactoring deve essere eseguito quando:

  • Aggiunta di codice duplicato al progetto. Poiché il codice duplicato è difficile da mantenere e le modifiche in un punto potrebbero richiedere aggiornamenti in molti altri posti.
  • Aggiunta di una funzionalità. Il refactoring semplifica l'aggiunta di nuove funzionalità.
  • Quando si corregge un bug, è necessario eseguire il refactoring perché il bug verrà scoperto automaticamente.
  • La revisione del codice è l'ultima fase del refactoring del codice prima che le modifiche vengano implementate in produzione.

Gestire gli odori del codice

I problemi sul codice sono a volte indicati come odori di codice. Questi sono i problemi affrontati durante il refactoring. Sono più facili da trovare e riparare.

Per esempio:

  • Metodi e classi di grandi dimensioni con cui è molto difficile lavorare.
  • Utilizzo incompleto o errato del concetto di programmazione orientata agli oggetti.
  • Codice che rende difficile aggiungere eventuali modifiche.
  • Codice duplicato e deprecato nel progetto.
  • Codice altamente accoppiato.

Tecniche di refactoring

Le tecniche di refactoring sono i passaggi per eseguire il refactoring del codice. Alcune delle tecniche di refactoring sono:

1. Il metodo di estrazione

// Problema

 function printInvoice() { $this->printHeader(); // Print details. print("name: " . $this->name); print("amount " . $this->getPrice()); }

// Soluzione

 function printInvoice() { $this->printBanner(); $this->printDetails($this->getPrice()); } function printDetails($price) { print("name: " . $this->name); print("amount " . $outstanding); }

Se hai un frammento di codice che può essere raggruppato, aggiungi un nuovo metodo per quella parte di codice e sostituisci il vecchio codice. Rende il codice più isolato e rimuove la duplicazione.

2. Estrai variabile

// Problema

 if (($student->getMarksinMath() > 60) && ($student->getMarksInPhysics() > 60) && ($student->getMarksinChemistry() > 60) && $this->pass) { // do something }

// Soluzione

 $mathResult = $student->getMarksinMath() > 60; $physicsResult = $student->getMarksinPhysics() > 60; $chemistryResult = $student->getMarksinChemistry() > 60; $hasPassed = $this->pass; if ($mathResult && $physicsResult && $chemistryResult && $hasPassed) { // do something }

Per espressioni di grandi dimensioni come quella visualizzata nel problema, che è molto difficile da capire, è possibile creare variabili diverse per ciascuna espressione. Rende il codice più leggibile. Ma questo metodo dovrebbe essere applicato con cautela. Tuttavia, ha i suoi svantaggi. Il codice verrà eseguito anche se la condizione è falsa, il che non è il caso del problema.

3. Il metodo in linea

// Problema

 function printResult() { return ($this->getResult()) ? “Pass” : “Fail”; } function getResult() { return $this->totalMarks > 300; }

// Soluzione

 function getRating() { return ($this->totalMarks > 300) ? “Pass” : “Fail”; }

Quando il corpo del metodo è più ovvio, usa questa tecnica. Sostituisci il metodo con il contenuto del metodo ed elimina il metodo. Riduce al minimo il numero di metodi indesiderati.

4. Temp in linea

// Problema

 $mathMark = $student->getMathResult(); return $mathMark > 60;

// Soluzione

 return $student->getMathResult() > 60;

Se è presente una variabile temporanea indesiderata che contiene solo il risultato dell'espressione, rimuovere la variabile con l'espressione stessa. Aiuta a sbarazzarsi di variabili non necessarie.

5. Sostituisci array con oggetto

// Problema

 $row = []; $row[0] = "Virat Kohli"; $row[1] = 70;

// Soluzione

 $row = new Player(); $row->setName("Virat Kohli"); $row->setNumberofCentury(70);

Se è presente un array con vari tipi di dati, sostituirlo con un oggetto. Perché i campi di una classe sono più facili da documentare e gestire rispetto agli array con vari tipi di dati.

6. Metodo parametrizzato

// Problema

 function fivePercentRaise() { } function tenPercentRaise() { }

// Soluzione

 function raise(percent) { }

Se più metodi eseguono un'azione simile sui dati, sostituire tutti i metodi con un metodo e passare i dati come argomenti. Rimuove i metodi duplicati e ridondanti.

7. Separa la query dal modificatore

// Problema

 function getInterest() { $this->interestAmount = $this->principal * 10 / 100; return $this->interestAmount; }

// Soluzione

 function setInterest() { $this->interestAmount = $this->principal * 10 / 100; } function getInterest() { return $this->interestAmount; }

Se un metodo restituisce un valore e modifica l'oggetto, dividere i due metodi. Uno per la modifica e un altro per restituire il risultato. Rimuove la possibilità di modifica involontaria di un oggetto.