Pignatelli.com - programmazione e social media marketing » PHP

Un saluto al Virgilio Search Team

Nicola — Tue, 23 Dec 2008 10:36:30 +0000

Bene essendo ormai passato il mio ultimo giorno di consulenza presso Matrix posso dire, senza dover poi sentirmi dire grazie, che grande, ecc. che i tre anni passati dentro il gruppo della Search di Virgilio sono stati molto belli. Spesso si parla delle aziende italiane come delle entità che scimmiottano la New Economy americana, che sono pronte a copiare tutto ma non sanno creare nulla.

Vi invito a guardare come è cambiata l’interfaccia del motore di ricerca Virgilio nell’ultimo anno. Tutto questo è frutto del lavoro di ragazzi in gamba, che pur con i loro difetti, hanno dei pregi e una passione per i loro compiti che ho riscontrato in pochissime persone lungo lo Stivale.

Mi piacerebbe fare i loro nomi, ma la privacy me lo impedisce, inoltre non vorrei che un giorno per colpa mia le loro email fossero tempestate di domande assurde o inutili.

Vi dico che se gli parlate scoprirete che sono persone normali, non se la tirano e sono sempre disponibili a dare una mano nell’ambito tecnologico a chi lo chiede.

Alcuni di loro hanno dei blog, ma non sta a me svelarne gli url, altri non li hanno perchè così indaffarati che non riescono a crearlo; altri ancora sono troppo intenti a raffinare le tecniche SEO sui blog precedenti.

Beh un saluto a tutta la Search, ed anche al super Capo, che nonostante il grado che ricopra è una persona sempre disponibile e che non disdegna momenti di ilarità con i suoi sottoposti.

Bye bye

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.

PHP Refactoring – Introduzione

Nicola — Wed, 29 Oct 2008 13:17:06 +0000

Refactoring, ovvero ottimizzazione del codice esistente.

Troppo spesso come programmatori dobbiamo mettere mano a codice sporco, scritto male e pieno di bug, con il rischio che l’eliminazione di un errore generi altri bug a catena.

Le soluzioni sono due:

Prendere un bel foglio bianco e pianificare da zero l’applicativo;
individuare la possibilità di suddividere il programma in porzioni autonome e riscrivere il codice di quest’ultime, in modo da migliorarlo senza apportare macro cambiamenti istantanei.

Il primo caso è quello preferito da ogni sviluppatore, ma purtroppo per esigenze contingenti (budget, tempistiche di messa online) il meno praticabile.

A questo punto siamo costretti ad intraprendere la strada della seconda soluzione, ovvero il refactoring.

Ma quali vantaggi può portarci intraprendere questo passo? Perchè, filosoficamente parlando, tutte le novità sono belle ed interessanti, ma alla fine bisogna sempre fare un raffronto fra costi e benefici.

Direi che i maggiori benefici possono essere qui riassunti:

Minor numero di righe di codice;
Individuazione di uno stile univoco di programmazione;
Scomposizione del codice in patterns riutilizzabili ben consolidati;
Leggibilità del codice;
Testing automatico del proprio codice.

Ricordatevi che il refactoring non è un metodo che si esaurisce in due minuti, e che non viene eseguito con cambiamenti massivi, ma è granulare e lungo nel tempo.

Concludiamo l’articolo introducendo i principali caposaldi del refactoring che andremo ad analizzare:

Incapsulamento interno dello stato di un oggetto;
Riduzione del codice di una classe;
Eliminazione di codice non autoesplicativo;
Naming convention per proprietà e metodi della classe;
Estrazione di metodi;
Semplificazione di istruzioni condizionali e ripetitive;

Buon proseguimento nelle prossime puntate.

Singleton Pattern in PHP

Nicola — Mon, 06 Oct 2008 13:05:25 +0000

Requisiti :

nessuno

Conoscenze PHP consigliate:

La proprietà static applicata alle variabili;
Sintassi versione 5;
L’istruzione require_once;
Programmazione ad oggetti.

Capita spesso che durante l’esecuzione di uno script si utilizzi ripetutamente la stessa classe.

Per ogni richiamo dell’istanza dell’oggetto viene allocata memoria. Un esempio è la classe che gestisce la connessione al database, utilizzata più volte durante l’elaborazione.

Come fare allora per risparmiare la memoria allocata ?

Fortunatamente esiste un filone della programmazione che si occupa di quest’argomento: dare una soluzione ai problemi che quotidianamente si presentano ai programmatori, in modo da risparmiare tempo e non dover ogni volta reinventare “la ruota”.

L’oggetto che utilizzeremo per la soluzione al problema dell’allocazione esponenziale di memoria è il Singleton Pattern.

Come esempio creiamo una classe HelloWorld che sarà richiamata tramite il suo Singleton in ogni punto del programma.

I file che andremo ad utilizzare sono i seguenti:

HelloWolrd.php
SingletonHelloWorld.php
testSingletonHelloWorld.php

PHP – Classe per gestire il layout delle pagine

Nicola — Tue, 16 Sep 2008 16:15:46 +0000

Requisiti di sistema :

Web Server installato;
PHP versione 5.0 o superiore;

Conoscenze PHP consigliate:

Sintassi versione 5;
L’istruzione include;
Programmazione ad oggetti;

Le conoscenze richieste in questo tutorial potrebbero non servire nella creazione del codice, in quanto si cerca di dare informazioni tali da poter “far camminare” il creatore delle pagine da solo, ma si consiglia lo stesso un’infarinatura generale.

Questo tutorial è stato testato sotto un Server Linux e Windows, con il PHP versione 5.

Vi spiegherò come creare una classe che ci permette di separare il layout, ovvero lo strato presentazione, dalla logica dell’applicativo. I file che andremo a creare sono i seguenti:

Template.class.php;
TemplateException.class.php;
File .html presenti nella directory template.

PHP – Creazione di una contatore per il sito

Nicola — Wed, 30 Jul 2008 11:53:15 +0000

Requisiti :

Server con Apache installato;
Server con PostGreSql (Sql Server) installato;

Conoscenze PHP consigliate:

Le variabili Session;
L’istruzione include;
Conoscenza dell’SQL;

Questo tutorial è stato testato sotto un Server Linux, con il PHP 4 e con l’SQL Server PostGreSql, ma nulla vieta di provarlo sotto Windows, e se si vuole usare l’SQL Server MySQL basta sostituire le funzioni proprie del PHP per il PostGreSql con quelle del MySql (per il manuale di riferimento vai su www.php.net).

Se volete avere un’interfaccia per Linux per editare i vostri database dovete andare su http://www.greatbridge.org/project/phppgadmin/projdisplay.php.

In questo tutorial vi spiegherò come creare un contatore per il proprio sito.

Dovete creare un database in PostGreSql con nome contatore contenente un solo campo, chiamato visite, di tipo numerico (int8), appartenente alla tabella conteggio.

Poi dovete creare una funzione chiamata IncrementaContatore, a cui vengono passati tre parametri, lo username e la password per interfacciarsi al PostGreSql ed il nome del database da utilizzare.

Di seguito è inserito il codice da inserire nel caso volessimo avere un contatore nelle nostre pagine: