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 :
- Determinare il codice da estrarre dal metodo esistente.
- Creare un nuovo metodo con il codice precedentemente estratto.
- Dare al nuovo metodo un nome chiaro che spieghi qual è il suo utilizzo.
- 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!
