Refactoring del tuo codice php

Refactoring del tuo codice php

Di Vincenza Neri


php refactoring scrivere codice sviluppatore php

Al giorno d’oggi, uno dei linguaggi di programmazione più usati è, senza dubbio, il linguaggio PHP. Non è un caso, dunque, che noi di Aulab siamo forti sostenitori dell’apprendimento di questo linguaggio.

Perché imparare PHP e diventare sviluppatori PHP

Diverse volte, nel corso del tempo, abbiamo accennato alle potenzialità di PHP: diventare sviluppatori PHP è incredibilmente proficuo, non solo per il fatto di essere tra i linguaggi di programmazione più richiesti, la cui conseguenza è, ovviamente, quella di trovare più rapidamente una possibilità di impiego nel mondo dello sviluppo web, ma anche per la semplicità della sua sintassi ad occhi inesperti che aspirino a diventare back end developer.
Prima di consigliarti un corso php online, lezioni php, o un coding bootcamp vogliamo ragguagliarti su un concetto che ti sarà utile, per altro, con qualunque altro tipo di linguaggio.

Il refactoring

Procedendo nel tuo cammino da studente a sviluppatore di siti web, sicuramente dovrai fronteggiare il processo di refactoring.
Il refactoring è il processo di modifica e ristrutturazione del codice senza cambiarne la funzionalità. Con molta probabilità adesso ti starai chiedendo ciò che ognuno di noi si è chiesto quando ha approcciato la prima volta questo discorso: perché, se il mio codice è funzionale, dovrei fare del refactoring?
 

Ebbene, non sempre un codice funzionante è un buon codice. Imparerai, con il tempo e con i vari progetti, che la leggibilità e la semplicità sono le chiavi fondamentali per rendere il codice mantenibile e sostenibile nel tempo

Certamente, agli inizi, il tuo obiettivo sarà far funzionare una parte di codice. Man mano che il progetto andrà avanti e sarà modificato, per un motivo o per un altro, tuttavia, ti accorgerai che l’atto di modificare il codice già scritto ti porterà via molto più tempo di quanto potessi immaginare.

Qui subentra il refactoring: grazie ad esso si può migliorare il codice funzionante e renderlo facile da leggere e modificare anche nel futuro.

Vediamo, adesso, delle pratiche che ti potranno essere utili nella scrittura del codice. Nei nostri esempi utilizzeremo sempre il linguaggio PHP ma, come già detto, queste pratiche possono essere utili in tutti i linguaggi di programmazione

 

1 - Sii espressivo

Partiamo da una cosa che potrebbe sembrarti semplice, ovvero, scrivere del codice espressivo. Fare in modo che il codice sia autoesplicativo è una buona pratica apprezzata da molti sviluppatori php e non. 

In linea teorica, se utilizzassi i nomi corretti per variabili e funzioni potresti riuscire a capire che cosa fa il codice senza leggerlo per intero e senza entrare nel flusso della logica: una vera manna dal cielo se ritorni su un progetto dopo tanto tempo o se stai modificando il codice scritto da un tuo collega!

Vediamo insieme qualche esempio:

 

Esempio 1 Naming

 

Prima:
 

//  Non è chiaro cosa faccia questo metodo con la stringa fornita.

//  Stiamo impostando lo stato? Stiamo controllando lo stato?

$status = $user->status('pending');

 

Dopo:

// Aggiungendo "is" ai nomi, rendiamo più chiare le nostre intenzioni.

// Verifichiamo se lo stato dell'utente è uguale alla stringa indicata.

// Anche il nuovo nome della variabile ci fa supporre che sarà un booleano

$isUserPending = $user->isStatus('pending');


Esempio 2 Naming
 

Prima:

// Cosa otteniamo? Il nome della classe? Il nome completamente qualificato? O il percorso?

return $factory->getTargetClass();


Dopo:

//  È il percorso che stiamo ricevendo indietro

//  Se l'utente cerca il nome della classe, questo è il metodo sbagliato

return $factory->getTargetClassPath();


 

2 - Extract 

Questo metodo di refactoring consiste nel separare un metodo estraendo un po' di codice e creando un nuovo metodo. 

Lo scopo di questa rifattorizzazione è quello di migliorare la comprensione del programma, “spacchettando” un metodo troppo lungo, oppure un metodo che implementa più funzioni in ciascuna di esse. 

Il refactoring consiste nelle seguenti fasi : 

  1. Determinare il codice da estrarre dal metodo esistente.
  2. Creare un nuovo metodo con il codice precedentemente estratto.
  3. Dare al nuovo metodo un nome chiaro che spieghi qual è il suo utilizzo.
  4. Sostituire il codice estratto con la chiamata del nuovo metodo.

 

Esempio 1 Extract

Prima : 

//  Codice duplicato (metodi "file_get_contents", "base_path" ed estensione del file)

//  A questo punto non ci interessa COME si ottengono gli esempi di codice

public function setCodeExamples(string $exampleBefore, string $exampleAfter)

{

    $this->exampleBefore = file_get_contents(base_path("$exampleBefore.md"));

    $this->exampleAfter = file_get_contents(base_path("$exampleAfter.md"));

}

 

Dopo :
 

public function setCodeExamples(string $exampleBefore, string $exampleAfter)
{ 

    // Il nostro codice ora dice cosa stiamo facendo: ottenere un esempio di codice (non ci interessa come)

    $this->exampleBefore = $this->getCodeExample($exampleBefore);
    $this->exampleAfter = $this->getCodeExample($exampleAfter);
}

// ✅ Il nuovo metodo può essere utilizzato più volte ora


private function getCodeExample(string $exampleName): string

{
    return file_get_contents(base_path("$exampleName.md"));
}

 

Esempio 2 Extract

 

Prima:

// Molteplici clausole "where" rendono la lettura difficile

// Qual è lo scopo?

User::whereNotNull('subscribed')->where('status', 'active');

 

Dopo:
 

// Questo nuovo metodo ci dice cosa sta accadendo

// Se abbiamo bisogno di maggiori dettagli controlliamo il metodo “subscribed”

// Il metodo "subscribed" può essere usato anche da altre parti ora

User::subscribed();


 

3 - Ritorna il più presto possibile

Il concetto di ritorno anticipato si riferisce a una pratica in cui si cerca di evitare l'annidamento di codice, suddividendo una struttura in casi specifici. 
In cambio, otterremo un codice più lineare, molto più facile da leggere e da comprendere. Ogni caso è separato e facile da seguire. Non abbiate paura di usare più dichiarazioni di ritorno.

 

Esempio 1 Return anticipato

Prima:

public function calculateScore(User $user): int

{
    if ($user->inactive) {
        $score  = 0;
    } else {

        if ($user->hasBonus) {
            $score = $user->score + $this->bonus;
        } else {
            // Gli occhi sono in continuo movimento a causa dei diversi livelli di identificazione degli if annidati.
            $score = $user->score;
        }
    }

    return $score;
}

 

Dopo : 

public function calculateScore(User $user): int
{
    // ✅ I casi limite vengono controllati per primi

    if ($user->inactive) {
        return 0;
    }

    // ✅ Ogni caso ha una propria sezione che lo rende facile da seguire passo per passo

    if ($user->hasBonus) {
        restituisce $user->score + $this->bonus;
    }

    return $user->score;
}


Questi sono 3 semplici modi per iniziare a scoprire il mondo del refactoring con php. Ovviamente, prima di applicarli, tutti gli sviluppatori php del tuo team dovranno essere d’accordo. La comunicazione all’interno di un team è fondamentale.

Se vuoi continuare a studiare il mondo del refactoring ti consigliamo Refactoring Guru: un sito veramente molto efficace per addentrarti in questo mondo!

Impara a programmare in 3 mesi con il Corso di Coding Hackademy su Laravel PHP

Diventa Sviluppatore web in 3 mesi

Scopri il coding bootcamp Hackademy

Programma Completo