Pignatelli.com - programmazione e social media marketing » Refactoring

PHP Refactoring – Lez. 4: Estrazione di codice e eliminazione di variabili temporanee

Nicola — Fri, 05 Dec 2008 10:03:26 +0000

Spesso nei metodi di una classe troviamo del codice che può essere riutilizzato in vari punti della stessa, oppure notiamo che messe in quella posizione non danno alcun significato intuitivo.

Un miglioramento della leggibilità dell’oggetto è estrarre questo gruppo di righe con un significato comune e metterle in un metodo che sarà richiamato ogni volta che si presenterà la necessità.

Un altro problema è la presenza di variabili temporanee, che non fanno altro che aumentare i rischi di bug e possono essere sostituite da codice autoesplicativo, nella forma di un metodo privato della classe.

Di seguito è fornito un esempio per meglio chiarire il concetto:

Errato

class Conto {

public function liquidita() {

$interessi = 0,025;

……………………………….

$totaleCredito = $this->db->getRow(1);

$creditoDisponibile = $interessi * $totaleCredito;

return $creditoDisponibile;

}

Esatto

class Conto {

private $interessi;

public function __construct($interessi) {

$this->setInteressi($interessi);

}

public function setInteressi($interessi) {

$this->interessi = $interessi;

}

public function getInteressi() {

return $this->interessi;

}

public function liquidita() {

return $this->totaleCredito() *

$this->getInteressi();

}

private function totaleCredito() {

………………………

return $this->db->getRow(1);

}

Come potete vedere dall’esempio precedente siamo passati da un metodo con un’accozzaglia di variabili temporanee, dfra cui una contenente una costante, ad un insieme di semplici metodi autoesplicativi e richiamabili in più punti.

Come esempio può sembrare banale, ma applicato ad un programma complesso vi permette di risolvere ed eliminare molte fonti di bug.

PHP Refactoring – Lez. 3: metodi di una classe

Nicola — Wed, 12 Nov 2008 11:00:01 +0000

Per quanto riguarda i metodi di una classe, vale anche in questo caso la naming convention esposta in precedenza per le proprietà della classe stessa. Le ripetiamo per comodità qui di seguito:

Se composto da singola parola tutto in minuscolo; per esempio valuta();
Se composta da più parole la prima lettera di ciascuna, a partire dalla seconda, in maiuscolo, tutte le altre minuscole; per esempio aggiungiElemento();
Il nome del metodo deve essere autoesplicativo.

In aggiunta a queste regole consideriamo anche le seguenti:

Se il nome del metodo è composto da più azioni scinderlo in tanti metodi quante sono le azioni;
La lunghezza del corpo del metodo non deve superare le 40 righe;
Il numero dei parametri non deve superare un massimo di 4;

Nome metodo composto da più azioni

Mettete il caso che nello scrivere il codice di una classe abbiate un metodo con la seguente signature:

public function controllaImmagazzina($prodotto)

Il codice del metodo è il seguente:

class Magazzino {

public function controllaImmagazzina($prodotto) {

if ($prodotto==null) {

return “prodotto non settato”;

} else if (substr($prodotto->getCodice(), 0, 3)==”CAT”) {

return “prodotto con vecchia catalogazione”;

} else if ($prodotto->getIngombro()>10) {

return “prodotto troppo ingombrante”;

}

$db = new Db(”mysql”);

$db->update($prodotto);

}

………………………………………

}

come potete vedere, abbiamo inserito in un unico metodo azioni che potrebbero tornarci utili anche singolarmente; per questo motivo dobbiamo scindere ogni azione in un nuovo metodo e nel caso ci serva utilizzarle contemporaneamente creiamo un ulteriore metodo che le richiami in sequenza.

Seguendo le indicazioni appena fornite, il codice precedente dovrebbe apparire come segue:

class Magazzino {

…………………………………………

public function controlla($prodotto) {

if ($prodotto==null) {

return “prodotto non settato”;

} else if (substr($prodotto->getCodice(), 0, 3)==”CAT”) {

return “prodotto con vecchia catalogazione”;

} else if ($prodotto->getIngombro()>10) {

return “prodotto troppo ingombrante”;

}

return “”;

}

public function immagazzina($prodotto) {

$db = new Db(”mysql”);

$db->update($prodotto);

}

public prendeInCarico($prodotto) {

$msg = $this->controlla($prodotto);

if ($msg !== “”) {

echo $msg;

} else {

$this->immagazzina($prodotto);

echo “Presa in carico andata a buon fine”;

}

$objProdotto = new Prodotto();

$objMagazzino = new Magazzino();

$msg = $objMagazzino->prendeInCarico($objProdotto)

echo $msg;

Riscrivendo il codice lo abbiamo reso più leggibile e riutilizzabile, nel caso volessimo solo controllare un prodotto all’interno di un altro metodo, o solamente immagazzinare un prodotto che non necessita di controllo.

Analizziamo ora gli altri requisiti.

PHP Refactoring – Lez. 2: proprietà array di una classe

Nicola — Tue, 11 Nov 2008 08:09:41 +0000

Oggi parleremo delle proprietà composte di una classe, ovvero di proprietà contenenti un array.

Abbiamo visto nella lezione precedente (PHP Refactoring – Lez. 1: proprietà di una classe) come scrivere le proprietà semplici di una classe.

Per quanto riguarda le proprietà composte valgono le regole di naming convention introdotte nel precedente tutorial, eccetto i metodi di accesso alle stesse. Di seguito lo standard da seguire a livello di classe.

Metodo addXXX

Per aggiungere un elemento ad una proprietà composta utilizzeremo un metodo con la seguente signature:

public function addXXX($valore, $chiave=null)

Dove XXX deve essere sostituito con il nome della proprietà.

Di seguito è fornito un esempio:

class Classe {

private $alunni;

public function addAlunni($valore, $chiave=null) {

if (is_array($valore)) {

foreach($valore as $posizione => $elemento){

if ($chiave!=null) {

$this->alunni[$posizione] =

$elemento;

} else {

$this->alunni[] = $elemento;

}

} else if ($chiave == null) {

$this->alunni[] = $valore;

} else {

$this->alunni[$chiave] = $valore;

}

Come si può notare i parametri da passare sono due: il primo obbligatorio, il secondo opzionale.

Non appena entriamo nel metodo addXXX viene controllato se il parametro $valore è un array. in caso affermativo cicliamo su quest’ultimo, e se il parametro $chiave è null accodiamo gli elementi nella proprietà; se invece $chiave è diverso da null inseriremo il valore $elemento nella chiave $posizione.

Nel caso $valore non sia un array e $chiave sia uguale a null inseriremo $valore direttamente nella proprietà $alunni.

Infine l’ultimo caso è se il parametro $chiave è valorizzato; in tal caso inseriremo $valore nella posizione $chiave della proprietà $alunni della classe.

Metodo removeXXX

Per rimuovere un elemento da una proprietà composta utilizzeremo un metodo con la seguente signature:

public function removeXXX($chiave=null)

Dove XXX deve essere sostituito con il nome della proprietà.

Di seguito è fornito un esempio:

class Classe {

private $alunni;

public function removeAlunni($chiave=null) {

if (is_array($chiave)) {

foreach($chiave as $posizione=> $valore){

unset($this->alunni[$valore]);

}

} else if ($chiave == null) {

$this->alunni = array();

} else {

unset($this->alunni[$chiave]);

}

Non appena entriamo nel metodo removeXXX viene controllato se il parametro $chiave è un array. in caso affermativo cicliamo su quest’ultimo, ed eliminiamo tutti gli elementi alle posizioni corrispondenti ai valori contenuti nel parametro del metodo.

Nel caso $chiave non sia un array ed sia uguale a null resetteremo la proprietà $alunni.

Infine l’ultimo caso è se il parametro $chiave è valorizzato; in tal caso elimineremo il valore corrispondente alla posizione $chiave nella proprietà $alunni della classe.

Metodo getXXX

Per recuperare degli elementi da una proprietà composta utilizzeremo un metodo con la seguente signature:

public function getXXX($chiave=null)

Dove XXX deve essere sostituito con il nome della proprietà.

Di seguito è fornito un esempio:

class Classe {

private $alunni;

public function getAlunni($chiave=null) {

if (is_array($chiave)) {

$elementi = array();

foreach($chiave as $posizione=> $valore){

$elementi[$valore] = $this->alunni[$valore];

}

return $elementi;

} else if ($chiave == null) {

return $this->alunni;

}

return $this->alunni[$chiave];

}

Non appena entriamo nel metodo getXXX viene controllato se il parametro $chiave è un array. in caso affermativo cicliamo su quest’ultimo, ed alla fine ritorniamo un array contenente i valori degli elementi richiesti.

Nel caso $chiave non sia un array ed sia uguale a null restituiremo tutta la proprietà $alunni.

Infine l’ultimo caso corrisponde al parametro $chiave valorizzato; in tal caso restituiremo il valore corrispondente alla posizione $chiave nella proprietà $alunni della classe.

Chiudiamo la lezione assemblando tutto il codice finora scritto e applicandolo ad un piccolo esempio, chiarificatore:

PHP Refactoring – Lez. 1: proprietà di una classe

Nicola — Fri, 31 Oct 2008 08:53:18 +0000

Quando scriviamo una classe ognuno di noi usa delle sue convezioni.

Io consiglio di utilizzare le seguente sulle proprietà di una classe:

Se composta da singola parola tutto in minuscolo; per esempio $nome;
Se composta da più parole la prima lettera di ciascuna, a partire dalla seconda, in maiuscolo, tutte le altre minuscole; per esempio $nomeAziendaItaliana;
Se rappresenta una costante composta da singola parola scriverla tutta in maiuscolo; per esempio ELEMENTI;
Se abbiamo una costante composta da più parole scriverla tutta in maiuscolo con un trattino fra le parole; per esempio ELEMENTI_PER_RIGA
Il nome della variabile deve essere autoesplicativo

Tutte le proprietà di una classe sono private ed è possibile accedervi tramite i metodi getXXX e setXXX, il cui livello di accesso deve essere public, in modo che si possa accedere allo stato interno dell’oggetto da qualunque punto. Al posto di XXX mettiamo il nome della proprietà.

Di seguito è fornito un esempio per meglio chiarire il concetto:

Errato

Esatto

class Prova {

public $nomeclasse;

private $mia_x1;

const costante_della_classe;

const pagine;

}

class Prova {

private $nomeClasse;

private $miaDataDiNascita;

const COSTANTE_DELLA_CLASSE;

const PAGINE;

public function setNomeClasse($nome) {

$this->nomeClasse = $nome;

}

public function getNomeClasse() {

return $this->nomeClasse;

}

Ma perchè dobbiamo fare tutto questo ? Le proprietà di una classe rappresentano lo stato dell’istanza di un oggetto, quindi si deve accedere solamente tramite i metodi pubblici, deputati a scatenare le azioni per la modifica.

Un esempio reale è la lampadina: noi siamo interessati al suo stato, ovvero incandescente o fredda, ma agiamo su quest’ultimo tramite le azioni accendere e/o spegnere, le quali rappresentano i nostri metodi.

Per quanto riguarda l’accesso delle proprietà in PHP 5 possiamo usare un trucchetto, possibile grazie alle funzioni magiche __set e __get.

Se non vogliamo usare direttamente nel codice le funzioni getXXX e setXXX possiamo fare come nel seguente esempio:

class Prova {

private $_nomeClasse;

public function __set($nome, $valore) {

call_user_func(array($this, “set”.ucwords($nome)), $valore);

}

public function __get($nome) {

call_user_func(array($this, “get”.ucwords($nome)));

}

public function setNomeClasse($nome) {

$this->_nomeClasse = $nome;

}

public function getNomeClasse() {

return $this->_nomeClasse;

}

$obj = new Prova();

$obj->nomeClasse = ‘prova’;

echo $obj->nomeClasse;

Il trucco consiste nel seguire una certa nomenclatura nei nomi ed usufruire delle funzioni magiche del linguaggio.

Il nome che utilizziamo al di fuori della classe non è altro che la proprietà, ma senza l’underscore come primo carattere. Non esistendo una variabile di classe con tale nome, il PHP lancia la funzione __set o __get, se esistenti, passandogli nel primo caso nome proprietà e valore da immagazzinare, nel secondo caso solo il nome.

Requisito essenziale per il funzionamento è che:

la variabile fittizia utilizzata al di fuori dell’oggetto segua la naming convenction della proprietà interna alla classe, ad esclusione dell’underscore che non deve essere presente;
esistano i metodi setXXX e getXXX per la proprietà richiamata;
la variabile interna da utilizzare sia semplice, in quanto con un array il funzionamento non sarà come lo si desidera.

Nel caso dell’array vedremo quali metodi utilizzare in un prossimo articolo.

Un grazie ad Enrico per alcuni utili suggerimenti nella stesura del codice.