Indice degli argomenti - fabiofoggia.files.wordpress.com · Con PHP si possono fare non solo...

Approfondimenti sul PHP

Indice degli argomentiIntroduzione al PHP....................................................................................................................2Che cos'è il PHP?........................................................................................................................2 Vantaggi dovuti all’uso del PHP................................................................................................3 Come inserire il codice PHP......................................................................................................4Variabili e tipi di dato.................................................................................................................9Variabili......................................................................................................................................9Le funzioni fondamentali in PHP..............................................................................................12Funzione phpinfo()....................................................................................................................12Funzione echo().........................................................................................................................12Funzioni exit() e die()...............................................................................................................13Funzioni definite dall'utente......................................................................................................15Cookies......................................................................................................................................18Nozioni preliminari...................................................................................................................18Il formato di un cookie..............................................................................................................18

......................................................................................................................................................18Cookies & PHP.........................................................................................................................19 La funzione setcookie()............................................................................................................20Inclusione di files......................................................................................................................21Inclusione di file esterni............................................................................................................21Inclusione di file statici.............................................................................................................21I comandi: Include e Require....................................................................................................22Il ruolo dell'estensione..............................................................................................................23Operazioni in PHP....................................................................................................................24Le date.......................................................................................................................................24 Operazioni più complesse........................................................................................................25Le sessioni.................................................................................................................................26Creare una sessione...................................................................................................................26Un esempio completo................................................................................................................27

......................................................................................................................................................28Il Web Server............................................................................................................................28 L'interprete PHP.......................................................................................................................28PHP come applicazione CGI.....................................................................................................29PHP come modulo del server web............................................................................................29PHP – My SQL ........................................................................................................................30Breve introduzione ai Database relazionali...............................................................................30La struttura della Query............................................................................................................40Zend 2.0....................................................................................................................................44Introduzione..............................................................................................................................44Alcuni problemi attuali.............................................................................................................44Il nuovo modello ad oggetti......................................................................................................45

1


Introduzione al PHP

Che cos'è il PHP?Il PHP (Professional Home Pages), è un linguaggio di programmazione: lo scopo del linguaggio è quello di consentire agli sviluppatori web di realizzare in modo veloce pagine dinamiche. Per pagine dinamiche si intendono pagine il cui contenuto viene, almeno in parte, generato nel momento in cui le stesse vengono richieste al web server.

Un esempio classico di pagina dinamica è fornito dai ben noti motori di ricerca: i risultati che ci vengono restituiti a seguito di una interrogazione non sono pagine web statiche, bensì documenti generati "su misura", sulla base della nostra richiesta.

Tornando al PHP, la definizione "ufficiale" tratta dal manuale in lingua inglese, su www.php.net, chiarisce le caratteristiche peculiari di questo linguaggio, e precisamente:

• il PHP è un linguaggio di scripting

• è un linguaggio "HTML-embedded"

• opera server-side, cioè lato server

Vediamo, uno per volta, il significato di questi punti.

Il PHP è un linguaggio di scripting. I programmi scritti in linguaggio PHP, denominati brevemente script, vengono eseguiti tramite un apposito software, l'"interprete" PHP. Quest' ultimo si occupa di leggere il codice PHP e, interpretandone le istruzioni, esegue le operazioni corrispondenti (ad esempio la lettura di un file o un calcolo aritmetico). Dunque il PHP è quello che tecnicamente si definisce un linguaggio interpretato ed in questo esso si differenzia da altri linguaggi di programmazione, come ad esempio C++ e Java, il cui codice sorgente, per poter essere eseguito, deve prima essere compilato (tradotto cioè in codice macchina).

È "HTML-embedded". Questa caratteristica si riferisce al fatto che il codice PHP è immerso nell'HTML; gli script sono inseriti, in altre parole, nelle pagine HTML in cui devono produrre i loro effetti. Il web server riconosce le pagine PHP, distinguendole da quelle "statiche", sulla base dell'estensione, che non sarà la solita .htm o .html ma piuttosto .php3, .phtml o simile; quando il server riconosce una estensione associata a PHP passa il testimone all'interprete, lasciando che sia quest'ultimo ad occuparsene.

Opera server-side. Il PHP opera lato server. Ciò vuol dire che tutta l'elaborazione di uno script avviene sul server, prima che questi spedisca la pagina al browser (il "client"). Di conseguenza, chi accede ad una pagina PHP non ha la possibilità di leggere le istruzioni in essa contenute: essendo state processate, ciò che il client vedrà sarà il risultato dell'elaborazione; per riassumere: il client vedrà cosa fa lo script ma non come lo fa.

L'esempio sopra citato del motore di ricerca è immediato e familiare, tuttavia la necessità di generare automaticamente il contenuto di pagine web si presenta in molte altre situazioni. Si pensi ad un qualsiasi sito Internet che fornisce in tempo reale (o quasi reale) gli indicatori dell'andamento del mercato azionario, o i risultati della giornata sportiva, o la situazione del traffico automobilistico, etc.; se non si vuole andare troppo lontano si pensi al caso più concreto dell'azienda che ha bisogno di pubblicare su web il proprio catalogo di prodotti o servizi: sono esigenze non troppo dissimili. In queste ed in molte altre situazioni occorre avere a disposizione degli strumenti

2

http://www.php.net/


che consentano una agevole manutenzione di un sito web e allo stesso tempo rendano possibile la comunicazione con uno o più database.

Semplice e potente, il linguaggio PHP rappresenta la soluzione ideale ad una vastissima gamma di esigenze, come indiscutibilmente dimostrato, del resto, dalla sua crescente popolarità e dal sempre maggiore numero di applicazioni Internet/intranet basate su di esso.

Vantaggi dovuti all’uso del PHP

Il PHP offre una varietà di funzionalità e vantaggi e di seguito ne sono elencati i principali:

• l'interprete PHP (o processore di hypertesto PHP) può essere integrato facilmente nel web server Apache come modulo ed è piuttosto leggero, in confronto ad altri tool.

• è disponibile gratuitamente (i dettagli della licenza li trovate sul sito, oppure nel file LICENSE della distribuzione in sorgente). - funziona sui sistemi UNIX (Linux compreso) ed anche sui sistemi Windows, permettendovi così di portare facilmente gli script da un ambiente all'altro.

• è già fornito di tutte le librerie per accesso ai database più comuni e di tutte le funzioni per la gestione dei cookies, delle sessioni di navigazione, per l'utilizzo di protocolli di rete, per la generazione dinamica delle immagini e di tutto quello di cui avete bisogno per programmare pagine web dinamiche anche complesse con poca fatica.

• facilita il debugging: fa uscire gli errori direttamente sulle pagine web e/o nell'errorlog, indicando chiaramente il tipo di errore, il percorso completo dello script che ha generato l'errore e il numero di riga su cui si è fermato il parser.

• può essere utilizzato anche come linguaggio di scripting al di fuori del web, ad es. per produrre script destinati ad essere chiamati dalla shell. Basta compilarne la versione CGI.

Per queste ragioni, sempre più siti scelgono PHP come tecnologia di scripting. PHP è la tecnologia alternativa ad ASP (Active Server Pages) di Microsoft con la differenza che mettere su un server web con Linux, Apache, MySQL (o PostgreSQL) e PHP non costa nulla in termini di software.

Con PHP si possono fare non solo manipolazione di database tramite interfaccia web e report (anche grafici) di dati di un database, ma anche cose divertenti, come sondaggi online, forum, chat, giochi, contatori.

3


Come inserire il codice PHP

Per la realizzazione di una pagina PHP dobbiamo per prima cosa settare l’estensione del file php(di default .php3). Infatti quando al Web Server viene chiesta una pagina con estensione .php3 egli gira la pagina direttamente all'engine, che ha poi il compito di capire cosa interpretare e di cosa lasciare così com'è e di restituirci la pagina. Dobbiamo infine vedere dove posizionare il codice e come inserirlo.

Chiariamo, innanzitutto, il primo punto: vogliamo realizzare una pagina che faccia uso di PHP? Bene, allora il posto dove andare a collocare il codice necessario è proprio la nostra pagina.Tipicamente i nostri script saranno posizionati nella prima parte del documento HTML (ad esempio per effettuare calcoli, elaborare eventuali parametri, etc.) o nel punto della pagina dove dovranno produrre il loro output.

La sintassi da utilizzare per inserire (o immergere) del codice PHP in un documento HTML è molto semplice e può essere utilizzata in diverse varianti. Un frammento di codice sarà, in ogni caso, delimitato da appositi marcatori, simili ai tag HTML: un tag di apertura contrassegnerà l'inizio di una sezione del documento contenente codice PHP (da eseguire sul server); un tag di chiusura contrassegnerà la fine di tale sezione. Diverse sintassi possono essere usate per l’inserimento dei tag, di seguito riportiamo alcuni possibili modi:

1. <?php ...codice PHP... ?>Questo è il metodo di default per inserire un’istruzione php. Tutto quello che si trova all'interno dei

tag verrà processato dall'engine!

2. <? ...codice PHP... ?>

3. <script language="php">...codice PHP...</script>Questa sintassi è simile a quella di Javascript e può essere molto utile nell'utilizzo di editor HTMLvisuali che non conoscono le estensioni PHP. E' attivo di default.

4. <% ...codice HTML... %>Questa è la sintassi utilizzata dalle ASP .

Ecco un esempio di pagina HTML contenente del codice PHP che non fa nient'altro che mostrare il consueto messaggio di saluto "Ciao mondo!".

<html><head>

<title>Esempio 1</title></head><body>

<h1> Esempio 1 </h1>

<?php// Questo è codice PHP racchiuso tra i tag "classici"echo "<p> Ciao mondo! </p>";

4


?>

</body></html>

In alternativa alla sintassi dell'esempio precedente, ma in modo del tutto equivalente, è possibile usare una forma più concisa del tag di apertura, usando <? invece di <?php:

<?// Questo è codice PHP; il tag di apertura è in forma concisaecho "<p> Ciao mondo! </p>";?>

L’ esempio appena visto mostra la sintassi da adottare per includere del codice PHP in una pagina web nella sua forma più rappresentativa. Non mancano, comunque, ulteriori alternative. In primo luogo, è possibile configurare l'inteprete PHP affiché supporti anche i tag in stile ASP (Active Server Pages); in questo caso, quindi, i marcatori di apertura e chiusura diventano, rispettivamente, <% e %>. Il codice dell'esempio "Ciao mondo" si riscrive allora:

<%

// Questo è codice PHP delimitato da tag in stile ASP

echo "<p> Ciao mondo! </p>";

%>

L'uso di quest’ultima sintassi è da ritenersi, in linea di massima, sconsigliato: infatti se, da un lato, essa è perfettamente equivalente a quella standard, dall'altro l'adozione di uno stile "ibrido" può portare ad una scarsa leggibilità del codice e dar luogo ad ambiguità.

Tuttavia, vi sono talune situazioni in cui può essere opportuno (o necessario) derogare alla regola sopra citata; ad esempio, quando l'ambiente di sviluppo web, sia che si tratti semplicemente di un editor HTML, come Microsoft FrontPage, sia di sofisticati sistemi di content management, digerisce poco i tag specifici del PHP. Occorre tener presente, infatti, che il PHP, per quanto semplice, è un linguaggio di programmazione, pensato da programmatori per programmatori, ed i programmatori sono abituati a lavorare direttamente sul codice.

Nelle suddette situazioni si può ricorrere alla stessa sintassi utilizzata per gli script lato client, come JavaScript o VBScript, nel modo seguente:

<script language="php">

// Questo è codice PHP delimitato dal tag (HTML) <script>...</script>

echo "<p> Ciao mondo! </p>";

</script>

Il tag utilizzato è il più familiare <script></script>, il cui attributo language va impostato su "php".

Abbiamo visto in quali e quanti modi è possibile immergere del codice PHP in un documento HTML; non rimane altro da dire se non che la scelta della sintassi più adatta ad ogni specifica situazione è rimessa alle vostre preferenze.Da questo punto di vista, e da molti altri, il PHP lascia ampi margini di libertà.

5


Vogliamo ora soffermarci su una importante caratteristica del PHP: l'“invisibilità” del codice!

Per capire di cosa si tratta vediamo immediatamente un esempio:

Cominciamo, allora, considerando il listato seguente.

<html>

<head>

<title>Codice che scompare!</title>

</head>

<body>


echo "<h1>Codice che scompare</h1>";

echo "<p>In un precedente...</p>";

</script>

</body>

</html>

Salviamo il tutto in un file con estensione .php3 e carichiamo il file sul nostro spazio web. Si noti che, in questo passaggio, stiamo assumendo di avere a disposizione un server con supporto PHP: almeno per ora può essere indifferentemente quello del nostro Internet Service Provider o il nostro PC, se abbiamo installato il software necessario; al contrario, in mancanza di questo requisito non saremo in grado di effettuare nessuna prova.

Accediamo adesso alla pagina (l'indirizzo sarà del tipo http://.../nostrofile.php3) e visualizziamone il codice HTML. Se tutto ha funzionato quello che vedremo sarà:

<html>

<head>

<title>Codice che scompare!</title>

</head>

<body>

<h1>Codice che scompare</h1><p>In un precedente...</p>

</body>

</html>

Osserviamo subito che non vi è nessuna traccia dello script PHP: ci viene restituito solo il risultato dell'elaborazione e non esiste alcun modo per risalire al codice originale. Se non fossimo stati noi a scrivere la pagina, non avremmo modo di sapere se questa era già così (cioè non conteneva codice

6

ma solo HTML puro) o se, oltre a scrivere quello che vediamo, ha anche calcolato 50 numeri primi o fatto chissà cos'altro.

Grazie a questa caratteristica il nostro codice è al sicuro e possiamo affidargli qualsiasi informazione con la garanzia che nessun client sarà in grado di carpirla indebitamente.Esistono, del resto, dei casi concreti in cui la suddetta invisibilità del codice è addirittura essenziale. Ad esempio, quando si accede ad un database, è necessario autenticarsi, cioè fornire un nome utente ed una password, che sono per antonomasia informazioni riservate; l'autenticazione, inoltre, deve essere effettuata tutte le volte che uno script si collega al database, per cui necessariamente la coppia user/password deve essere contenuta nel codice.

E' evidente, quindi, come il PHP ci renda un gran servigio, consentendoci di custodire tali informazioni nelle nostre pagine dinamiche in tutta sicurezza.

Un altro risvolto degno di nota è rappresentato dai commenti; i commenti sono previsti sia nell'HTML che nel PHP e la loro funzione è sostanzialmente la stessa, cioè quella di fornire indicazioni e chiarimenti sul contesto in cui vengono inseriti; tuttavia, esiste una profonda differenza: i commenti PHP sono parte integrante del codice e risulteranno invisibili al client; viceversa, i commenti HTML saranno visibili.

Il seguente frammento di pagina PHP ed il relativo output dovrebbero chiarire ulteriormente questo punto.




// Questo e' un commento PHP e sara' invisibile

echo “”;

</script>

L'output sarà il seguente:

<!—

Questo e' un commento HTML e sara' visibile dal client

-->



Il meccanismo di elaborazione lato server delle pagine PHP è piuttosto semplice; per comprenderlo, basta accennare alle modalità in cui l'interprete PHP può operare. Quando un file, contraddistinto da una opportuna estensione, viene passato al “motore” PHP, quest'ultimo si pone in modalità HTML, la modalità predefinita, ed inizia ad elaborarlo. La modalità HTML prevede che l'interprete non faccia assolutamente nulla e si limiti ad inviare al client tutto quello che legge dal file in elaborazione.Le cose cambiano quando viene incontrato uno dei costrutti sintattici che denotano l'inizio di un blocco di istruzioni PHP; ne è un esempio il tag <script language="php"> che demarca l'inizio

7


del codice nel nostro primo esempio. In questa situazione, infatti, l'interprete passa in una nuova modalità (la modalità PHP, per l'appunto), in cui ciò che legge dal file è una serie di istruzioni; quello che fa è eseguirle ed inviarne l'output al client.

Ovviamente, la commutazione tra le due modalità possibili può avvenire un numero qualsiasi di volte, in funzione dell'alternarsi nella pagina di blocchi di semplice HTML e di pezzi di codice PHP. I casi “estremi” sono due:

1. la pagina contiene solo HTML, nel qual caso l'interprete non entrerà mai nella modalità esecutiva e tutto il contenuto del file sarà inviato (inalterato) al client; sebbene questa non sia una situazione scorretta, per questioni di prestazioni può essere opportuno cambiare l'estensione del file in .htm o .html, evitando l'inutile “filtro” dell'interprete PHP

2. la pagina contiene solo codice PHP, per cui l'interprete entrerà subito nella corrispondente modalità e ci resterà fino alla fine; al client verrà inviato solo l'output dello script, tipicamente quello “stampato” con le istruzioni echo o print.

8


Variabili e tipi di dato

Variabili

Uno degli aspetti base d’ogni linguaggio di programmazione sta nelle variabili.

Le variabili del PHP sono molto flessibili e vengono riconosciute automaticamente; la variabile PHP viene definita nel suo contenuto dall'engine.

L'inizializzazione di una variabile può essere fatta semplicemente assegnandole un valore (tramite l'operatore =). Non deve essere definita all’inizio, né tanto meno si deve definire di che tipo è, anche se a volte può essere utile e necessario farlo!

In uno script PHP i nomi di variabili sono prefissati dal simbolo $ (dollaro); ad esempio, la seguente istruzione:

$a = $b + $c

assegna ad una variabile di nome a la somma dei valori di altre due variabili, rispettivamente b e c.

Per creare una variabile è sufficiente assegnarle un valore; in altre parole non vi è alcuna necessità di dichiararla esplicitamente, come avviene, invece, in altri linguaggi. Si parla, dunque, di dichiarazione implicita. Se vogliamo visualizzare nella nostra pagina PHP il valore di una variabile, in modo che venga mostrata dal browser del visitatore, possiamo usare la funzione echo (verrà trattata in dettaglio in seguito). Ad esempio:

// Questa istruzione visualizza il valore della

// variabile $a

echo $a;

A disposizione del programmatore c'è anche un certo numero di variabili predefinite, cioè di variabili il cui valore è già impostato. Solitamente queste variabili contengono informazioni circa l'ambiente di esecuzione dello script PHP. Esaminiamone alcune di uso frequente.

• La variabile $PHP_SELF contiene il percorso dello script in esecuzione;

• La variabile $HTTP_HOST contiene il nome del server su cui lo script viene eseguito;

• Le variabili $HTTP_REMOTE_HOST e $HTTP_REMOTE_ADDR, invece, forniscono rispettivamente il nome di dominio e l'indirizzo IP del visitatore.

L'elenco completo delle variabili predefinite può essere visualizzato usando la funzione phpinfo()(verrà trattata in dettaglio in seguito)

9


Vediamo adesso cosa può contenere una variabile. Abbiamo parlato di valori, ma a che tipo di valori facciamo riferimento? Introduciamo dunque i tipi di dato che PHP mette a disposizione del programmatore.

I tipi di dato supportati da PHP si distinguono in tipi scalari e tipi compositi: sono tipi scalari i numeri (sia interi che in virgola mobile) e le stringhe; sono tipi compositi gli array e gli oggetti.

Per assegnare anche il tipo alla variabile questa è la sintassi:

$variabile = (int) 1;

Un array in PHP può corrispondere sia ad un vettore, cioè ad una struttura dati in cui ogni elemento è individuato da un indice numerico, sia ad una tabella di hash, cioè ad una collezione di coppie nome/valore. In PHP, infatti, tali strutture sono sostanzialmente la stessa cosa.

L'inizializzazione di un array è fatta assegnandole un valore... ma in modo diverso!! Ecco l'esempio:

$nomi[ ] = "Davide" // Questo valore è identificato come array $nomi[0]

$nomi[ ] = "Fabio" // Questo valore è identificato come array $nomi[1]

.... così via!

In questo modo quando viene inserito un nuovo valore nell'array, questo diventa l'ultimo. E' importante ricordare che i membri di un array partono nel conteggio da 0 e non da 1.

Esistono array anche multidimensionali differenti da quelli visti in precedenza che invece erano array monodimensionali. Ecco alcuni esempi di array multidimensionali:

# Example 1:

$a["color"] = "red";

$a["taste"] = "sweet";

$a["shape"] = "round";

$a["name"] = "apple";

$a[3] = 4;

# Example 2:

$a = array(

"color" => "red",

"taste" => "sweet",

"shape" => "round",

"name" => "apple",

3 => 4

);

10


Entrambi questi array costruiscono la medesima struttura, ma sono scritti in maniera differente! Se

provassimo ad esempio a richiamare una funzione del genere:

echo $a[name];

A video comparirebbe:

apple

Ora vediamo un array multidimensionale più complesso:

$a = array(

"apple" => array(

"color" => "red",

"taste" => "sweet",

"shape" => "round"

),

"orange" => array(

"color" => "orange",

"taste" => "sweet",

"shape" => "round"

),

"banana" => array(

"color" => "yellow",

"taste" => "paste-y",

"shape" => "banana-shaped"

)

);

Per identificare un valore dell'array si devono richiamare 2 dimensioni... cosi:

echo $a["apple"]["taste"];

E come output ci sarebbe:

sweet

11


Le funzioni fondamentali in PHP

Funzione phpinfo()

La prima funzione di cui ci occupiamo è phpinfo(). Quello che fa generare dinamicamente una (lunga) pagina contenente moltissime informazioni sulla versione di PHP installata e sull’ambiente di esecuzione. Per richiamare phpinfo() è sufficiente uno script come il seguente:

<html><head><title>phpinfo()</title></head><body><?phpphpinfo();?></body></html>

La pagina web generata da phpinfo() consente di visualizzare la configurazione della nostra installazione di PHP, di conoscere quali estensioni sono disponibili e, cosa particolarmente importante,consente di imparare i nomi delle variabili predefinite che PHP mette a disposizione del programmatore.

Funzione echo()

La seconda funzione è certamente la più utilizzata in ogni script PHP: echo(). La funzione echo() serve per scrivere (o stampare) l'output che viene inviato al browser del visitatore che accede al nostro script. Si consideri il seguente esempio:

<html><head><title>echo</title></head><body>

<?phpecho"<h1>Benvenuto!</h1>";?>

</body></html>

La pagina che verrà inviata al client, dopo l'elaborazione da parte dell'interprete PHP, sarà la seguente:

<html><head><title>echo</title></head>

12


<body>

<h1>Benvenuto!</h1>

</body></html>

Grazie ad echo() possiamo visualizzare il contenuto di variabili; nell'esempio seguente viene mostrato, nel messaggio di benvenuto, anche il nome di dominio del sito su cui lo script viene eseguito (nome contenuto nella variabile $HTTP_HOST).

<html><head><title>echo</title></head><body>

<?phpecho"<h1>Benvenuto su $HTTP_HOST!</h1>";?>

</body></html>

A rigore occorre rilevare che echo non è propriamente una funzione bensì un costrutto del linguaggio; per questo motivo non è necessario, come si è visto negli esempi, utilizzare le parentesi tonde per racchiudere gli argomenti.

Funzioni exit() e die()

Le ultime due funzioni che esaminiamo sono exit() e die(); entrambe producono il risultato di arrestare l'esecuzione dello script, con la differenza che die() consente anche di stampare un messaggio. Ad esempio il seguente script

<html><head><title>exit</title></head><body><? exit(); ?><p>Questa frase non si vedrà</p></body></html>

produce questo output:

<html><head><title>exit</title></head><body>

13


Le funzioni exit() e die() possono essere utilizzate, quindi, per gestire eventuali situazioni di errore che non consentono di proseguire l'esecuzione del nostro script PHP (i cosiddetti "errori fatali"). In queste circostanze può essere conveniente usare die() per mostrare un messaggio di errore appropriato.

Vediamo un semplice esempio. Nello script seguente controlliamo il valore della variabile globale $n e mostriamo un messaggio di errore, bloccando l'esecuzione del programma, se questo è maggiore di 1.

<html><head><title>die</title></head><body><?$n = 5;if ($n > 1) die("<h1>\$n è maggiore di uno!!!</h1>");?><h1>$n è minore o ugale ad uno!</h1></body></html>

Il risultato sarà il seguente:

<html><head><title>die</title></head><body><h1>$n è maggiore di uno!!!</h1>

Se, invece, sostituiamo l'istruzione $n=5 con $n=1 il risultato diventa:

<html><head><title>die</title></head><body><h1>$n è minore o ugale ad uno!</h1></body></html>

14


Funzioni definite dall'utenteNello scrivere codice PHP capita molto spesso di trovarsi a riscrivere pezzi di codice quasi identici all'interno di un singolo script o di più script associati a una stessa applicazione. Se per un piccolo progetto un rapido susseguirsi di copia e incolla permette di raggiungere un risultato ragionevole in poco tempo, con il crescere del numero di linee è facile perdere il controllo del fiume di caratteri se non si cercano di raccogliere gli elementi concettualmente simili.

Un buon sistema per farlo potrebbe essere quello di definire funzioni personalizzate per l'applicazione corrente che siano in grado di eseguire compiti precisi che risultano utili più volte nel corso del programma. Allo stesso modo in cui la funzione mysql_num_rows() dà il numero di righe restituite da una query MySQL, potremmo ad esempio definire la funzione my_num_books() che, dato il cognome di uno scrittore, restituisce il numero di libri che ha scritto: analogamente a quanto fatto dalla funzione per MySQL, questo comando eseguirà delle richieste a una base dati, ma permette al programmatore di aumentare il livello di astrazione perdendo di vista per un momento i dettagli dell'interazione col database per passare a lavorare con elementi logici interni all'applicazione, libri e autori e non più database e query.

Procediamo quindi nella realizzazione della nostra prima applicazione che fa uso di funzioni, per renderci conto che in alcuni casi questi strumenti del linguaggio PHP non servono solo ad organizzare i dati ma permettono di ottenere risultati altrimenti inaccessibili.

Supponiamo di voler costruire uno script PHP che genera un form con alcuni campi testo per permettere all'utente di immettere dati anagrafici (nome, cognome, indirizzo, e-mail, telefono, ...). A parte tutto il resto del codice, dovremo sicuramente ripetere molte volte righe del tipo:

<input type="text" name="nomecampo" value="valorecampo">cambiando soltanto il nome e il valore del campo. Possiamo rendere il tutto più maneggevole creando una funzione che riceve come argomenti il nome e il valore del campo di testo che vogliamo inserire e restituisce l'intera stringa. Creiamo per lo scopo un file chiamato funzioni.php e digitiamo:

function campotesto ($nome,$valore){

return true;

}

Abbiamo già creato la prima funzione, che si chiama campotesto (e per il momento non fa nulla). Queste poche righe contengono tutti gli elementi fondamentali della definizione di una funzione: il nome, i parametri passati e il valore restituito.

Analizziamoli singolarmente:

Per quanto riguarda il nome, in questo caso campotesto, l'unico requisito è che sia unico tra le funzioni di PHP e che non contenga caratteri speciali (compresi spazi). Normalmente basta scegliere una parola italiana per essere sicuri di non aver scelto un nome esistente (print chiaramente esiste in PHP, ma non certo stampa).

Tra parentesi tonde viene racchiuso l'elenco dei parametri richiesti per il funzionamento della funzione, separati da virgole. Quando verrà chiamata la funzione, dall'interno dello script PHP, sarà necessario passarle due valori. Se voglio un campo testo di nome url e valore predefinito http://www.latoserver.it, nel mio codice chiamerò la funzione con questi parametri:

15


$campo = campotesto('url','http://www.latoserver.it')

Questi due valori che io passo alla funzione, vengono messi da PHP nelle due variabili indicate nella dichiarazione, $nome e $valore, in modo che il codice che metterò nella funzione possa manipolarli per restituire il risultato e metterlo nella variabile $campo.

L'ultimo elemento riguarda proprio la restituzione del risultato. La funzione deve terminare con la parola chiave return seguita da ciò che si vuole restituire. La versatilità di PHP permette di restituire sostanzialmente qualunque cosa: una stringa, un vettore, un valore logico o addirittura un oggetto. La variabile definita tramite la nostra funzione (nell'esempio $campo) assumerà tutte le caratteristiche del risultato: se è un vettore potremo leggerne gli elementi e se è un oggetto impostarne proprietà ed eseguirne metodi.

Esempio: la funzione campotesto

Dopo aver osservato in generale la struttura di una funzione, procediamo a costruire la funzione campotesto che serve al nostro script per generare form. Innanzi tutto, inseriamo una riga per controllare che il nome del campo non sia vuoto:

if(empty($nome)) { return false; }e poi costruiamo la stringa completa nel caso in cui il nome non sia vuoto:

$ret = '<input type="text" name="' . $nome . '" value="' . $valore . '" size="10" maxlength="40">';e quindi assembliamo la funzione.

Dopo aver creato questa prima funzione, dobbiamo inserirla all'interno del normale file PHP con la semplice accortezza di mettere prima la funzione di qualunque riferimento ad essa. Per sicurezza apriamo il file proprio con la definizione della funzione che abbiamo scritto in precedenza e solo in seguito introduciamo il codice per generare il form:

$tbox["nome"]="Massimo";

$tbox["cognome"]="Vassalli";

$tbox["email"]="[email protected]";

$tbox["telefono"]="055.202020";

echo '<form action="index.php">';

while(list($x,$y)=each($tbox)){

echo $x.': '.campotesto($x,$y).'<br>';

}

echo '<input type="Submit"></form>';

16

http://www.latoserver.it/php/funzioni/tbox.php.txt


In questa forma, senza la ridondanza tipica dell'HTML, il codice PHP risulta sicuramente più chiaro e permette di concentrarsi sempre più sugli elementi di programmazione piuttosto che sulla resa grafica.

Dal momento che la funzione campotesto è di utilità abbastanza generale, potremmo aver voglia di riutilizzarla in più documenti. Chiaramente è possibile copiare tutta la definizione ogni volta che si vuole usare la funzione. In questo modo però, oltre a trovarci impegnati in operazioni di copia e incolla poco eleganti, ci siamo messi in una situazione per cui per eseguire una modifica della funzione che venga "ereditata" da tutti gli script che la chiamano, dobbiamo modificare tutti i file PHP. Per ovviare a ciò conviene quindi mettere la definizione della funzione campotesto in un file a parte, tbox.php ad esempio, ed includerlo in cima a tutte le pagine in cui vogliamo usare la funzione da noi definita:

<? include("tbox.php"); ?>

In questo modo modificando la definizione in tbox.php viene influenzato tutto l'insieme delle pagine che costituiscono l'applicazione che stiamo sviluppando.

17


http://www.latoserver.it/php/funzioni/offline.php.txt


http://www.latoserver.it/php/funzioni/inline.php.txt


Cookies

Nozioni preliminari

Secondo una definizione "ufficiale", i cookies (letteralmente biscotti) sono un meccanismo generale che può essere utilizzato da connessioni lato server (come ad esempio script CGI) per memorizzare e recuperare informazioni sul lato client della connessione. Tale definizione è stata liberamente tradotta dal documento con il quale Netscape, che i cookies li ha inventati, ne pubblicava le specifiche.

Da un punto di vista più tecnico, i cookies rappresentano una delle possibili soluzioni alla mancaza di stato del web. Utilizzando i "biscotti" è possibile, sia pure con alcune limitazioni, mantenere delle informazioni sul client in modo persistente e quindi condividere uno stato attraverso più pagine o script.

Le possibili applicazioni sono numerose e sicuramente, esemplificandone alcune, ci renderemo conto di averne già incontrate. Il caso più tipico e rappresentativo ci viene fornito da quei siti su cui vediamo link del tipo "Personalizza questa pagina" che ci danno la possibilità di scegliere i colori con cui essa viene visualizzata e, sempre più spesso, il tipo di contenuti che più ci interessano. Un'altra applicazione tipica è quella di memorizzare determinate informazioni per evitare al navigatore di doverle immettere più di una volta; ad esempio, chi usa servizi di webmail spesso ha la possibilità, selezionando una apposita opzione, di fare in modo, al momento di accedere alla propria casella di posta, di essere "riconosciuto" e di dover inserire solo la password. Un ulteriore esempio è quello dei "carrelli della spesa", componente irrinunciabile dei siti di commercio elettronico.

Il formato di un cookie

Un cookie consiste innanzitutto di una coppia nome/valore; possiamo pensare ad esso come ad una variabile a tutti gli effetti. Questa è l'unica componente essenziale: le altre, illustrate nel seguito, sono facoltative e possono pertanto essere omesse.

Un cookie ha una data di scadenza (indicata in Inglese come expiration date); oltre tale data il cookie automaticamente cessa di esistere. Se al momento della creazione del cookie la scadenza non viene indicata, il cookie scompare alla chiusura del browser.

Ad ogni cookie sono associati anche un dominio (domain) ed un percorso (path); tali informazioni vengono utilizzate dal browser per stabilire quali siano i cookies validi per il sito in cui si sta navigando. Ovviamente la motivazione di questo meccanismo risiede nella necessità di impedire che gli script di un sito possano in qualsiasi modo manipolare i cookies di un sito diverso. I valori di default sono, rispettivamente, il nome di dominio ed il percorso corrente.

Infine, ogni cookie ha un attributo secure che, se impostato, lo contrassegna come riservato, per cui esso potrà essere trasmesso solo attraverso connessioni sicure (in particolare connessioni HTTPS). Per default tale attributo non è impostato.

18


Cookies & PHP

L'uso dei cookies in PHP è estremamente semplice anche perché avviene mediante un'unica funzione: setcookie(). Occorre precisare subito che si tratta di una funzione con una particolarità: non può essere utilizzata in un punto qualsiasi di uno script ma solo nella sua parte iniziale; più precisamente, setcookie() può essere chiamata esclusivamente prima che una qualsiasi porzione di pagina sia inviata al client (tipicamente, prima del tag <HTML>). Questo avviene perché la gestione dei cookies è realizzata a livello di intestazioni HTTP che, secondo quanto stabilito da tale protocollo, costituiscono la parte iniziale del flusso di dati di una connessione. Se non si rispetta tale regola le intestazioni HTTP si confonderanno con il contenuto della pagina e non produrranno il comportamento atteso (nel nostro caso specifico non verranno impostati i cookies desiderati).

Per il resto, una volta impostato un cookie questo sarà accessibile da PHP come una qualsiasi variabile; in altre parole, per ogni cookie esisterà una variabile avente lo stesso nome, mediante la quale è possibile accedere al valore corrispondente.

Inoltre, può essere reso disponibile (configurando opportunamente PHP o utilizzando nello script la direttiva <?php_track_vars?>) un array associativo, $HTTP_COOKIE_VARS, contenente tutte le coppie nome/valore relative ai cookies impostati. Un esempio di navigazione in tale array:

$i=0;while (list($nome,$valore)=each($HTTP_COOKIE_VARS)) {

echo "Nome del cookie: $nome - Valore: $valore <br>";$i++;

}echo "Ho contato $i cookies impostati.";Le variabili corrispondenti a cookies già impostati possono essere utilizzate solo in lettura: la creazione, la modifica e l'eliminazione dei cookies avvengono, invece, tramite la citata funzione setcookie().

Prima di passare all'esame della funzione setcookie() è opportuno citare un errore apparente che viene riscontrato frequentemente da chi si avvicina per la prima volta all'uso dei cookies. Se si impostano uno o più cookies all'inizio di uno script e poi si tenta di accedervi nella parte seguente del codice, le corrispondenti variabili risulteranno nulle. La spiegazione di questo è semplice: un cookie viene impostato mediante opportune intestazioni HTTP che il server inserisce nella sua risposta al client; di conseguenza, soltanto alla successiva richiesta da parte del client quest'ultimo includerà tra le intestazioni HTTP inviate anche quelle relative ai cookies (che permettono a PHP di creare le variabili corrispondenti).

Un espediente per aggirare tale problema viene suggerito dall'esempio seguente.

// Imposto il cookie

setcookie($nome,$valore);

// Cosi' lo rendo immediatamente disponibile nello script

$$nome=$valore;

19


La funzione setcookie()

La funzione setcookie(), in perfetta aderenza alle specifiche del formato dei cookies, prevede sei argomenti, di cui solo i primi due, nome e valore, sono obbligatori. Il prototipo della funzione è il seguente:

int setcookie(string nome, string valore, int scadenza,string percorso, string dominio, int sicuro);

L'uso più semplice di setcookie() viene illustrato dall'esempio seguente.

$nome="NomeUtente";$valore="Luca76";setcookie($nome,$valore);Il terzo argomento, la scadenza, è facoltativo; esso consiste di un timestamp come quelli ottenibili con time() e mktime(). Se non viene indicata alcuna scadenza, il cookie verrà automaticamente eliminato alla chiusura del browser. Se si ha necessità di utilizzare altri argomenti di setcookie di posizione successiva ma si desidera, al contempo, mantenere la scadenza di default, il parametro deve essere impostato a zero.

// Esempio: scadenza per un cookie che scomparira' tra 10 minuti

$scadenza=time()+600; // 600 = 60 secondi x 10 minuti

Quarto parametro, il dominio; consente di individuare quali cookies sono validi (accessibili) per un determinato sito. Per default, dominio viene impostato al nome del dominio corrente; può essere utile, tuttavia, utilizzare un valore diverso. Ad esempio, se il mio sito è www.miosito.com, con il valore predefinito di dominio i cookies impostati non risulteranno validi per un eventuale shop.miosito.com; usando, invece, ".miosito.com" lo saranno per tutti i domini che ricadono sotto miosito.com.

Il percorso ha anch'esso funzione di individuazione del campo di validità del cookie e, precisamente, serve a specificare il sottoinsieme di indirizzi URL in un dominio nei quali il cookie è valido. Ad esempio:

// percorso per un cookie valido in tutto il sito

$percorso="/";

/* percorso per un cookie valido solo negli indirizzi

sul sito che iniziano per 'public' */

$percorso="/public";

L'attributo sicuro, se impostato, denota il cookie come riservato; di conseguenza esso viene trasmesso soltanto attraverso connessioni sicure (in particolare, connessioni HTTPS). Il valore di default è zero (non viene richiesta una connessione sicura).

20

Inclusione di files

Inclusione di file esterni

L'inclusione di file esterni, come ad esempio frammenti di HTML, è una pratica molto frequente nella realizzazione di siti web. L'esempio classico è quello delle pagine web di un sito aziendale, su ognuna delle quali si vuole far comparire una intestazione con il logo ed il nome dell'azienda (ed eventualmente i link alle varie sezioni del sito) ed un fondo pagina con indirizzi, recapiti ed informazioni sul copyright.

Una soluzione molto utilizzata dai webmaster per rispondere a questo genere di esigenze è quella delle SSI, Server-Side Includes, cioè inclusioni lato server. Le inclusioni SSI, pur nella loro semplicità, spesso sono sufficienti allo scopo e, cosa non trascurabile, sono supportate praticamente da tutti i web server, assicurando quindi una elevata portabilità.

Le SSI, tuttavia, risultano inadeguate quando le esigenze diventano più sofisticate; in questi casi, la maggiore potenza e flessibilità fornita da un linguaggio di scripting, come PHP, possono essere un vero toccasana, consentendo di implementare, spesso in modo molto semplice peraltro, le funzionalità necessarie. Vediamo allora qual è l'equivalente in PHP delle Server-Side Includes.

Inclusione di file statici

Sebbene sia possibile utilizzare le Inclusioni Lato Server per includere l'output di applicazioni CGI o script, nella maggior parte delle situazioni in cui si utilizzano le SSI, lo si fa per incorporare in una pagina web il contenuto di uno o più file statici, tipicamente contenenti frammenti di HTML. In PHP si possono utilizzare a questo scopo le funzioni virtual e readfile.

La funzione virtual è disponibile in PHP solo quando esso è integrato, sotto forma di modulo, nel web server Apache, ed è del tutto analoga al comando SSI



E' importante tener presente che, esattamente come avviene nel caso del comando SSI, se la funzione viene utilizzata per includere nella pagina l'output di una applicazione CGI, quest'ultima dovrà produrre le intestazioni HTTP appropriate.

La funzione readfile prende in input un nome di file, eventualmente completo del percorso, e lo stampa sullo standard output. Una caratteristica interessante di questa funzione è la possibilità di accedere al file da includere anche tramite connessioni HTTP e FTP.

Esempio 1. Esempi di chiamate a readfile()

// Accedo ad un file sul server

readfile( "/home/luca/html/header.html" );

// Accedo ad un file via HTTP

readfile( "http://www.miosito.tld/copyright.txt" );

21

http://www.latoserver.it/SSI/


I comandi: Include e Require

Uno degli utilizzi più classici delle architetture Server Side è quello della creazione di pagine "dinamiche". Essendo la risposta del Server ad una richiesta di pagina .php3 puro codice HTML, questo sistema è un espediente molto elegante per modificare le pagine non intervenendo su tutto il codice ma solo sul file collegato al principale che contiene ciò che deve essere modificato.

All'interno di uno script è possibile includere altri file contenenti a loro volta codice PHP da eseguire; i costrutti del linguaggio preposti a questo scopo sono require e include. La possibilità di includere file esterni consente una organizzazione più razionale del codice, permettendo, ad esempio, di utilizzare funzioni o classi definite in librerie condivise, di facile riutilizzo. E' importante ricordare che quando il parser PHP analizza il file esterno si pone automaticamente in modalità HTML, per tornare in modalità PHP subito dopo; per questa ragione il codice PHP contenuto nel file deve essere racchiuso dagli appositi demarcatori.

Il comando INCLUDE è di facile utilizzazione. Questa è la sua sintassi più semplice:

<?phpinclude ('file.estensione');?>dove "file.estensione" sta per il nome del file da includere (es. include.inc).

La sintassi del comando REQUIRE è la stessa.

E' da notare poi che i comandi INCLUDE e REQUIRE possono essere utilizzati anche nel corso di cicli iterativi che richiamino la stessa funzione. Includendo il file in cui è presente un certo comando PHP esso sarà automaticamente incluso all'interno del ciclo.

Esempio 2. Uso del costrutto require()// Questa istruzione include ed esegue il file global.phprequire ( $DOCUMENT_ROOT."/phplib/global.php" );Ma qual è la differenza tra include e require?

• Il costrutto include viene valutato tutte le volte che viene invocato, cosa che può avvenire più di una volta se, ad esempio, esso compare all'interno di una iterazione. E’ possibile fare in modo che ad ogni esecuzione di include venga incluso un file diverso.

• Il costrutto require, invece, alla prima valutazione rimpiazza sé stesso con il contenuto del file incluso; di conseguenza se mettiamo una require all'interno di una iterazione, verrà sempre eseguito il contenuto del file esterno incluso la prima. Come nel caso, visto sopra, della funzione readfile, anche con i costrutti include e require è possibile accedere a file esterni mediante connessioni HTTP e FTP; ad esempio, l'istruzione seguente è perfettamente lecita:

include "http://www.miosito.tld/scripts/include.php";

22


Il ruolo dell'estensione

Le estensioni vengono utilizzate dal server web per riconoscere i file PHP come tali (distinguendoli, ad esempio, dalle normali pagine HTML) ed elaborarli nel modo corretto. In particolare, il server web provvederà ad attivare un apposito software, l'interprete o "motore" PHP, che prenderà in carico l'esecuzione dello script.

Per comprendere meglio questo punto si può compiere un semplice esperimento. E' sufficiente prendere un qualsiasi script PHP, modificarne l'estensione in ".txt" e pubblicarlo sul proprio spazio web. Accedendo alla pagina si vedrà visualizzato tutto il codice in essa contenuto; lo script infatti - a causa dell'estensione modificata - non verrà riconosciuto come tale e non sarà quindi eseguito.

Quando se ne presenti la necessità è possibile utilizzare estensioni arbitrarie per le pagine PHP; la scelta dell'estensione è puramente convenzionale. A questo scopo dobbiamo intervenire sulla configurazione del nostro server web (tipicamente Apache o Internet Information Server). Non è necessario quindi né ricompilare l'interprete PHP né modificarne la configurazione tramite il file php.ini.

Supponiamo che il nostro server web sia Apache; abbiamo due possibilità:

1. modificare la configurazione globale del nostro sito intervenendo sul file httpd.conf; si noti che ciò è possibile solo se abbiamo i privilegi di amministratore

2. modificare localmente la configurazione del sito mediante la creazione di un file .htaccess In entrambi i casi quello che dovremo fare è semplicemente aggiungere una riga al file di configurazione (httpd.conf o .htaccess), con cui specifichiamo quali estensioni vogliamo associare agli script PHP.

Vediamo un esempio. Se vogliamo aggiungere .php4 alle usuali estensioni, la riga che dovremo aggiungere al nostro file di configurazione sarà la seguente (se utilizziamo la versione 4 di PHP)

AddType application/x-httpd-php .php4Se invece utilizziamo la versione 3 del linguaggio la riga da inserire sarà la seguente

AddType application/x-httpd-php3 .php4

23


Operazioni in PHPLe date

Lavorare con date ed orari è un'operazione non banale, considerata la particolare struttura dati con cui si ha a che fare. In molte applicazioni, tuttavia, si ha necessità di manipolare date, confrontarle, validarle e così via. Vedremo in che modo possiamo operare su date ed orari nei nostri script PHP, ricorrendo ad esempi concreti.

Nel linguaggio PHP le date vengono rappresentate sotto forma di "timestamp": un timestamp è semplicemente un numero intero che corrisponde al numero di secondi trascorsi dalla cosiddetta "Unix epoch" (le ore 0:00:00 del primo gennaio 1970). Ad esempio, le ore 0:00:00 del primo gennaio 2001 corrispondono al timestamp 978303600.Per conoscere il timestamp corrispondente ad una certa data basta invocare la funzione mktime() passandole i parametri previsti e cioè, nell'ordine, ore, minuti, secondi, mese, giorno, anno. Un ulteriore argomento, opzionale, consente di tener conto dell'ora legale. Vediamo quale istruzione abbiamo utilizzato per determinare il timestamp mostrato in precedenza.

// Timestamp delle ore 0:00:00 del primo gennaio 2001

echo mktime(0, 0, 0, 1, 1, 2001);

I timestamp, naturalmente, sono poco comprensibili per un essere umano, per cui vediamo subito in che modo si possano tradurre in una forma "human readable". PHP ci mette a disposizione, a questo scopo, la funzione date(). Gli argomenti di date() sono due: il primo, obbligatorio, è una stringa che rappresenta il formato in cui codificare la data; il secondo, facoltativo, è il timestamp da formattare. Se quest'ultimo viene omesso, verrà considerato il timestamp corrente. Vediamo un esempio.

// Questa istruzione stampa la data corrente nel formato gg/mm/aaaa

echo "Data di oggi " . date("d/m/Y");

Nell'esempio mostrato, la stringa che esprime il formato in cui visualizzare la data è "d/m/Y". Ognuna delle lettere che vi compaiono corrisponde ad un elemento della data; nel nostro caso al giorno del mese (01-31), al mese (01-12) ed all'anno, espresso con quattro cifre. Si consulti la pagina del manuale PHP relativa alla funzione date() per un elenco completo delle lettere utilizzabili.

Ma come possiamo visualizzare la data in modo testuale? Ecco una possibile soluzione.

// Nomi dei giorni della settimana

$giorni = array( "Dom", "Lun", "Mar", "Mer", "Gio", "Ven", "Sab" );

echo "Oggi e': " . $giorni[date("w")];

In modo del tutto analogo si può ottenere il nome dei mesi. Per evitare di chiamare ripetutamente la funzione date() se ne può utilizzare un'altra, getdate(), che restituisce le informazioni sulla data ed ora correnti in un array associativo

24


Operazioni più complesse

Fino ad ora abbiamo considerato operazioni estremamente semplici sulle date; nel seguito mostriamo, invece, come eseguirne altre più evolute. In primo luogo, vediamo come sia possibile validare una data, cioè accertarsi che si tratti di una data valida. Per citare qualche esempio sono date non valide il 31 aprile o il 29 febbraio di un anno non bisestile. La funzione preposta alla verifica di una data è checkdate().// Verifichiamo una data (31 aprile 2001!?)

$giorno = 31;

$mese = 4;

$anno = 2001;

echo "La data $giorno/$mese/$anno ";

if (checkdate($mese,$giorno,$anno)) echo "è corretta.";

else echo "non è valida!";

Supponiamo adesso di voler confrontare due date per verificare se la prima è antecedente alla seconda. In PHP un modo rapido per risolvere il problema è quello di convertire entrambe le date nei corrispondenti timestamp e confrontare quelli.

// Data n° 1: ancora il primo gennaio 2001

$data1 = mktime(0, 0, 0, 1, 1, 2001, 0);

// Data n° 2: il 29 luglio 2001

$data2 = mktime(0, 0, 0, 7, 29, 2001, 0);

echo "La prima data è ";

if ($data1 < $data2) echo "precedente";

else echo "successiva";

echo " alla seconda.";

Altrettanto semplicemente si può calcolare il numero di giorni che separa due date arbitrarie, come mostrato nell'esempio seguente:

// Data n° 1: ancora il primo gennaio 2001

$data1 = mktime(0, 0, 0, 1, 1, 2001, 0);

// Data n° 2: il 29 luglio 2001

$data2 = mktime(0, 0, 0, 7, 29, 2001, 0);

echo "Tra le due date ci sono ";

echo ($data2 - $data1)/(60*60*24);

echo " giorni.";

La differenza tra i due timestamp, espressa in secondi, può essere convertita in giorni dividendo per 24 ore al giorno, 60 minuti l'ora, 60 secondi al minuto. L'unica particolarità riguarda l'ultimo parametro fornito a mktime() impostato a zero, in modo da ignorare l'ora legale.

25

Le sessioni

Creare una sessione

Quando abbiamo parlato dei cookies abbiamo visto che essi possono essere sfruttati per il mantenimento di un rudimentale stato. Il meccanismo dei cookies, tuttavia, presenta delle limitazioni intrinseche che lo rendono inadatto ad applicazioni complesse. Un esempio per tutti: vogliamo essere in grado di mantenere uno stato anche nell'eventualità in cui il browser del visitatore non supporti i cookies (o li abbia disabilitati).

Una sessione, in questo contesto, consiste di una serie di accessi alle nostre pagine PHP, effettuati in un determinato arco di tempo durante il quale viene mantenuto uno stato. Ogni sessione è individuata da un identificatore, univoco, utilizzato per l'associazione tra client e relativa sessione.

Per utilizzare le sessioni abbiamo bisogno essenzialmente di tre funzioni, e precisamente: session_start(), session_register() e session_destroy().La prima funzione, session_start(), viene invocata per creare una nuova sessione o per ripristinarla, nel caso sia stata creata in precedenza. Questa funzione tenta anche di impostare, nel browser, un cookie contenente l'identificativo di sessione, per cui è necessario che venga invocata all'inizio degli script, esattamente come nel caso della funzione setcookie().La funzione session_register(), invece, viene utilizzata per registrare delle variabili come variabili di sessione. Ad esempio, se abbiamo una variabile $nomeutente e vogliamo renderla persistente per tutta la durata della sessione, invocheremo session_register() nel modo seguente

// $nomeutente diventa variabile di sessione

session_register("nomeutente");

Infine, la funzione session_destroy() viene invocata per distruggere i dati relativi alla sessione, tipicamente al momento del "log out".

Come si vede, quindi, lavorare con le sessioni è piuttosto semplice. L'unico aspetto critico, al quale il programmatore deve prestare la massima attenzione, è quello della propagazione del SID,l’ identificatore di sessione. Sebbene, infatti, nella maggior parte delle situazioni reali, sarà sufficiente memorizzare tale valore in un cookie nel browser del visitatore (PHP lo fa automaticamente), è opportuno gestire anche il caso in cui i cookies non possano essere utilizzati (perché il browser non li supporta o è stato configurato per rifiutarli).

In questo "caso pessimo" è il programmatore PHP che deve preoccuparsi della propagazione del SID, modificando i link tra i vari script che condividono la sessione e passandolo come parametro. A dispetto di quanto possa sembrare, si tratta di un'operazione piuttosto semplice: basta includere nei link alle altre pagine PHP, il valore della costante SID, come nell'esempio seguente:

<!--Un esempio di link che propaga l'identificativodi sessione senza richiedere cookies

26


--><a href="altroscript.php?<?= SID ?>">Altro script</a>

Un esempio completo

Mettiamo in pratica quanto abbiamo imparato sulle sessioni realizzando un semplice esempio: la "sequenza di colori". Si tratta di uno script PHP che propone al visitatore di cliccare su uno dei tre colori disponibili (bianco, rosso e verde), mostrando al contempo la sequenza delle selezioni effettuate fino a quel momento. Il funzionamento dello script è molto semplice: la sequenza dei click sui vari colori viene memorizzata in un array, registrato come variabile di sessione.

Vediamo in dettaglio il codice. La prima cosa da fare è l'avvio della sessione: a tal proposito è importante ricordare che affinché PHP possa impostare il cookie con l'identificativo di sessione, questa chiamata di funzione deve avvenire prima che qualsiasi output sia inviato al browser del visitatore.

// Attivo (o ripristino) la sessione

session_start();

Il secondo passo è la registrazione dell'array $clicks come variabile di sessione.

// 'clicks' e' una variabile di sessione: devo registrarla

session_register("clicks");

Passiamo adesso all'analisi dei parametri passati dall'utente. Per prima cosa verifichiamo se è stato cliccato il link "Ricomincia da capo", che comporta l'azzeramento della sequenza (cioè dell'array).

// Devo azzerare?

if ($azzera) {

$clicks = array();

}Se l'utente ha cliccato su uno dei colori lo aggiungiamo alla sequenza, inserendo un nuovo elemento in coda all'array.

if ($click) {

$clicks[] = $click;

}Infine, arriviamo alla visualizzazione della sequenza dei colori. Se l'array che rappresenta la sequenza contiene almeno un elemento (quindi, se è stato scelto almeno un colore) vengono visualizzati tutti i suoi elementi; diversamente viene mostrata la scritta "(sequenza vuota)".

if (count($clicks)) {

foreach ($clicks as $colore) { echo "$colore "; }

} else {

27


echo "(sequenza vuota)"; }

Vediamo ora come creare il nostro ambiente di sviluppo web

Per realizzare ciò abbiamo bisogno di:

• un web server

• una distribuzione di PHP

• il database MySQL

Il Web Server

I web server attualmente più diffusi sono

• Apache, sviluppato dalla Apache Software Foundation, è disponibile sia per piattaforme Microsoft che per sistemi Unix.

• Internet Information Server, prodotto da Microsoft per i propri sistemi operativi. Questo software è commerciale per cui l'installazione è descritta nel manuale d'uso allegato al programma.

• Personal Web Server, prodotto anch'esso da Microsoft, accompagna il popolare editor visuale FrontPage.

• Xitami, prodotto dalla iMatix è un altro Web server Open Source disponibile sia per Unix che per ambienti Windows. Dal sito di Xitami è possibile scaricare il web server nella versione per il vostro sistema operativo.

• OmniHTTPd, prodotto dal Omicron Technologies Corporation è un web server con licenza gratuita per usi non commerciali. Esiste solo in versione per Windows.

L'interprete PHP

PHP viene distribuito sia sotto forma di codice sorgente, da compilare, sia in formato binario precompilato; le versioni binarie vengono comunque rese disponibili sia per la piattaforma Microsoft Windows, che per quella Linux in formato rpm.

Il modo più semplice per procurarsi una distribuzione aggiornata di PHP è quello di collegarsi al sito web ufficiale e scaricarla da lì.

Per Windows. Per gli utenti dei sistemi Windows sono disponibili due diverse distribuzioni di PHP, una minimale (più rapida da scaricare) ed una completa. A nostro è opportuno prelevare entrambi i file: infatti, mentre la versione leggera (php404pl1-installer.exe) contiene un programma capace di installare e configurare in modo automatico alcuni web server quali Xitami, PWS ed IIS, quella completa fornisce tutte le estensioni utilizzabili.

28

http://www.php.net/downloads.php

http://www.omnicron.ab.ca/index.html

http://www.xitami.com/download.htm

http://www.imatix.com/

http://www.microsoft.com/office/

http://www.microsoft.com/

http://httpd.apache.org/dist/httpd/binaries/linux/

http://httpd.apache.org/dist/httpd/binaries/win32/

http://www.apache.org/


Per Linux. Per gli utenti dei sistemi Linux è disponibile un solo file in formato tar.gz contenente i sorgenti di PHP. In questo caso quindi sarà necessario effettuare la compilazione insieme al server Apache.

L'installazione dell'interprete PHP può avvenire secondo due approcci alternativi, che differiscono tra loro per la modalità di interazione con il server web. Il primo approccio consiste nell'installazione di PHP sotto forma di applicazione CGI; il secondo nell'installazione sotto forma di modulo del server web.

PHP come applicazione CGI

Nell'installazione di tipo CGI, l'interprete PHP verrà invocato dal server web come qualsiasi altra applicazione in grado di comunicare con esso attraverso la Common Gateway Interface. L'interprete PHP, dunque, sarà un programma esterno al server web.

In questa situazione, l'esecuzione di uno script PHP consiste in una invocazione dell'interprete, al quale viene passato il percorso del file da eseguire tramite la variabile d'ambiente PATH_INFO.

Questo tipo di installazione è il più semplice ma comporta alcuni svantaggi, sia in termini di prestazioni che in termini di funzionalità. Le prestazioni vengono influenzate negativamente dalla necessità di creare un nuovo processo ogni volta che viene invocato uno script PHP, con un considerevole aggravio del carico di lavoro della macchina server. Inoltre, alcune funzionalità del linguaggio, in particolare quelle che richiedono una interazione più profonda con il server web, sono disponibili solo quando PHP viene utilizzato come modulo.

PHP come modulo del server web

L'interprete PHP può essere integrato nel server web sotto forma di modulo statico o dinamico. Nel primo caso (modulo statico) sarà necessario effettuare la ricompilazione del server web ed il risultato ottenuto sarà un nuovo eseguibile, completo di supporto PHP. Nel secondo caso (modulo dinamico) l'interprete PHP verrà compilato come libreria a caricamento dinamico: DSO (Dynamic Shared Object) su piattaforme Unix e DLL (Dynamic Link Library) su piattaforme Windows.

Notiamo che l'esecuzione di uno script PHP non richiede l'invocazione di un programma esterno (e quindi la creazione di un nuovo processo, come avveniva nell'ipotesi di installazione CGI) in quanto viene effettuata all'interno del server web.

L'installazione di PHP sotto forma di modulo del server web è quella che fornisce le prestazioni più elevate, peraltro senza rinunce in termini di funzionalità disponibili; tale approccio sarà quindi da preferire in contesti applicativi reali.

29


PHP – My SQL

Breve introduzione ai Database relazionali

I database sono delle strutture nelle quali è possibile memorizzare grandi quantità di informazioni, per poi ricavarle attraverso linguaggi di scripting come il PHP. Il punto di forza di un database sta nella velocità con cui le informazioni vengono trovate; dato il loro largo utilizzo ne esistono diversi tipi a seconda dell'uso che ne dobbiamo fare. Fra questi quello attualmente più diffuso è sicuramente il modello relazionale che ci permette di memorizzare i dati all'interno di tabelle.

Le tabelle saranno ovviamente costituite da colonne e da righe. Le colonne rappresentano le caratteristiche dell'elemento che vogliamo memorizzare. In particolare nel nostro esempio vorremo memorizzare un id, il titolo, il testo, la data, l'autore e magari anche l'indirizzo e-mail dell'autore. Per ogni elemento che inseriremo nella tabella verrà creata una nuova riga.

Vediamo un esempio:

Da notare, in particolare, la colonna id: questa, come potete immaginare, non contiene alcuna informazione che riguarda l'articolo. Anzi, vedremo che questo valore non sarà mai visibile all'utente. Il database, però, ha bisogno di poter distinguere i vari articoli e questo deve avvenire attraverso un campo (o un insieme di campi) univoco in ogni riga che prende il nome di chiave primaria. Questo campo, in questo caso, è un numero che si auto incrementa all'inserimento di ogni nuova riga. Ogni colonna della tabella avrà determinate caratteristiche a seconda dell'informazione che vogliamo memorizzare:

• id è, come detto, un numero intero positivo che si auto incrementa;

• titolo è una stringa di una certa lunghezza;

• data potrà essere memorizzata in diversi formati, ma vedremo in seguito quale utilizzare;

• testo è un'altra stringa, ma notevolmente più grande;

• autore e mail, infine, saranno anch'esse stringhe.

Un database può contenere più di una tabella con strutture differenti. Queste tabelle possono però avere informazioni incrociate e con un certo legame concettuale. Questi li possiamo definire attraverso relazioni (da cui il nome database relazionale).

30


E' importante prima di tutto chiarire un concetto: ognuno di noi ha disposizione un database che non viene memorizzato in un file specifico. In particolare questo viene memorizzato in un insieme di file che non è accessibile a chiunque. Anche se possedete un dominio e vi siete rivolti a un servizio di hosting a pagamento, questo non vi permetterà di accedere ai file: potrete modificarli indirettamente (quindi tramite query), ma non potrete copiarli o salvarli. Questo crea una limitazione nel senso che quando volete distribuire uno script, non potete fornire con esso anche il database. Dovete quindi fare in modo che l'utente crei le tabelle necessarie all'interno del suo database: potremmo quindi dirgli di accedere a phpMyAdmin e crearsi una tabella con determinate caratteristiche. Questo metodo, però, richiede una serie di conoscenze da parte dell'utente che probabilmente non ha. Quindi gli forniremo uno script che creerà per lui tutte le tabelle necessarie.

Prima di tutto, però, avremo bisogno di alcune informazioni relative all'accesso al database: l'host da cui si può raggiungere MySQL (generalmente è localhost); username e password per l'accesso al database; il nome del database. Questi quattro parametri vengono forniti dall'amministratore del nostro spazio web.

Quindi creeremo una pagina di nome config.inc.php con queste righe:

Abbiamo dato proprio questo nome al file per diversi motivi: config indica che il file contiene dei dati relativi alla configurazione dello script. Ovviamente possiamo chiamarlo come vogliamo, ma facendo così ci risulterà più facile distinguerlo dagli altri file. .inc ci ricorderà che questo file non è una pagina che verrà visualizzata direttamente, ma verrà inclusa all'interno di altre. Anche questa parte del nome può essere modificata, se non addirittura omessa.

.php invece viene inserito per motivi di sicurezza. Se qualcuno cercherà di visualizzare questa pagina con il browser, vedrà solo una pagina vuota. Il webserver, infatti, grazie a quest'estensione, prima di passare la pagina al browser, la farà elaborare dal modulo Php. Visto che non è previsto nessun output, sul browser verrà visualizzata solo una pagina bianca.

Da notare inoltre che non abbiamo chiuso i tag Php: questo perché in seguito aggiungeremo altre stringhe di configurazione.

A questo punto abbiamo tutti i dati necessari per la connessione al database. Questa la possiamo realizzare attraverso la funzione mysql_connect. Creiamo quindi una pagina di nome install.php con questo contenuto:

Come potete notare il codice richiama dal file di configurazione i parametri del database, poi li utilizza per connettersi.

La funzione mysql_connect richiede diversi parametri, di cui generalmente si utilizzano i primi tre, che sono proprio quelli che abbiamo richiesto all'utente. Se la connessione ha buon fine ci restituisce un identificatore alla connessione che noi memorizziamo in $db. Questa variabile la utilizzeremo ogni volta che vorremo fare un'operazione sul database. Se la connessione non dovesse andare a buon fine (per esempio se uno dei parametri fosse sbagliato) verrebbe restituito FALSE. Quindi dovremo verificare il buon esito della connessione aggiungendo di seguito:

31


Grazie a queste righe se la connessione dovesse fallire, otterremmo il messaggio di errore e l'interruzione dell'esecuzione del programma.

Fatto tutto questo dobbiamo specificare su quale database vogliamo lavorare e verificare nuovamente la riuscita dell'operazione:

In questo caso non abbiamo bisogno di memorizzare alcun valore, visto che la funzione restituisce solo TRUE o FALSE.

Dopo aver creato la connessione possiamo finalmente agire sul database. Vediamo quindi come creare una tabella utilizzando procedimenti differenti il cui risultato finale è però sempre identico.

In questo caso dovremo comunicare direttamente con il database, quindi dovremo mescolare i codici Php e Sql. I comandi che inviamo al database sono detti query che letteralmente significa domanda. Infatti noi chiediamo al database di compiere una certa operazione. In particolare gli chiederemo di creare una tabella con determinate caratteristiche. Aggiungiamo in fondo al file install.php:

Vediamo nel dettaglio che cosa chiede questa query:

CREATE TABLE news chiede la creazione di una tabella di nome news. In seguito, tra parentesi,

specificheremo le colonne di cui sarà composta e le loro caratteristiche.

id INT (5) UNSIGNED not null AUTO_INCREMENT: tutta questa parte indica le caratteristiche della prima colonna, cioè l'id. Questo dovrà essere un intero composto al massimo da cinque cifre. Ovviamente potete specificare un valore diverso se pensate che si possano inserire più di 99.999 articoli. Un limite ragionevole, però, ci consente di non sprecare inutilmente spazio per la memorizzazione di un numero eccessivamente grande. Visto che la numerazione parte da 1 il valore di id sarà sempre maggiore di zero e lo specifichiamo attraverso l'attributo UNSIGNED. In seguito imponiamo che il campo id sia sempre definito e che quindi non possa restare vuoto attraverso not null. Infine specifichiamo a MySQL che questo deve essere un campo AUTO_INCREMENT e che quindi deve pensarci lui a incrementarlo ogni volta che inseriamo un nuovo record.

titolo VARCHAR (255) not null è il campo che conterrà il titolo delle news. Gli assegnamo una stringa di lunghezza massima di 255 caratteri. Se specifichiamo una stringa di tipo varchar dobbiamo sempre specificare la lunghezza massima di cui sarà la stringa. Questa non potrà mai essere più di 255, quindi qui sfruttiamo al limite il tipo varchar. Anche il titolo dovrà sempre essere specificato (not null).testo TEXT not null Come abbiamo visto in precedenza anche il testo è una stringa. Ragionevolmente, però, il testo sarà più lungo del titolo e comunque più grande di 255 caratteri. Per

32


questo genere di stringhe esistono i tipi TINYTEXT (max 255 caratteri), TEXT (max 65.535 caratteri), MEDIUMTEXT (max 16.777.215 caratteri) e LONGTEXT (max 4.294.967.295 caratteri). Abbiamo scelto il tipo TEXT, perché questo è il più vicino alle possibili caratteristiche dell'articolo che verrà inserito, ma ovviamente si potrebbe utilizzare anche il tipo MEDIUMTEXT.

data INT (11) è il campo in cui memorizzeremo la data in formato timestamp. Questa è una delle tante possibilità che abbiamo a disposizione. In particolare si tratta di un numero intero equivalente al numero di secondi trascorsi a partire dall'ora 00:00 del 1 gennaio 1970. Utilizziamo questo formato, perché ci risulterà più semplice ricavare la data in qualunque formato.

autore VARCHAR (50) , mail VARCHAR (50) Anche l'autore e l'indirizzo e-mail vengono memorizzati in stringhe, ma questa volta non sarà necessario specificarli. Quindi sarà possibile inserire un articolo senza doverne indicare l'autore e/o il suo indirizzo e-mail.

PRIMARY KEY (id) Tramite questo comando indichiamo quale colonna sarà la chiave primaria, quindi quella che identificherà univocamente le righe. Automaticamente questo aggiunge al campo id la proprietà di unicità. Quindi se una riga ha un determinato numero di id, nessun'altra riga potrà avere lo stesso id.

Una volta definita la query, possiamo comunicarla al database attraverso la funzione mysql_query:

Anche questa funzione restituisce FALSE in caso di errore, generalmente quando la query contiene uno o più errori di sintassi.

Al termine dello script è sempre bene terminare la connessione al database:

Con questo il file di installazione è pronto, quindi chiederemo all'utente di eseguirlo una sola volta prima dell'utilizzo dello script.

Come detto in precedenza è possibile creare la tabella senza dover scrivere una pagina appositamente.

Questo metodo, infatti, è utile quando si vuole distribuire lo script, ma se lo creiamo per uso personale risulta più veloce crearla in altri modi. Uno di questi l'abbiamo già introdotto ed è quello di aiutarsi con phpMyAdmin.

In questo caso la creazione è molto semplice. Ci basta accedere al nostro phpMyAdmin, cliccare sul nome del database nella colonna di sinistra e inserire la query nella casella di testo con intestazione "Esegui una/più query SQL sul database":

Cliccando su "Esegui" la tabella verrà creata automaticamente da phpMyAdmin.

Vediamo adesso le operazioni da compiere per il corretto inserimento dei dati nel database.

La prima operazione sarà quella di verificare che la password sia stata inserita correttamente. Creiamo quindi la pagina save.php con le seguenti righe:

33


Anche in questa pagina abbiamo richiamato la funzione top() che genera il codice html relativo all'aspetto della pagina. Abbiamo poi confrontato la password inserita dall'utente, $pass, con quella memorizzata in config.inc.php, $password.

Avvenuto il riconoscimento dobbiamo subito controllare che i dati necessari siano stati inseriti. Questo eviterà fastidiosi errori da parte di MySQL. Infatti se noi non forniamo il contenuto dei campi not null, l'inserzione non può avvenire.

Quindi verifichiamo che i campi titolo e testo non siano vuoti o non contengano solo spazi:

Abbiamo utilizzato la funzione trim che ha lo scopo di eliminare caratteri vuoti dall'inizio e dalla fine della stringa. Questo eviterà di accettare stringhe composte da soli spazi e quindi senza contenuto informativo.

A questo punto verifichiamo che le stringhe non contengano caratteri particolari (come l'apice o le virgolette), quindi li facciamo precedere dallo slash. Questo avviene automaticamente in php4, ma il nostro utente potrebbe utilizzare una versione precedente. Quindi inseriamo queste righe che prima eliminano gli slash, poi li reinseriscono:

Quando sarà il momento di visualizzare l'articolo, potremmo avere problemi con alcuni caratteri, in

particolare con quelli che vanno in contrasto con i tag html. Per questo conviene ancora sostituire il carattere < con l'equivalente html < e inserire nel testo i tag di fine riga:

Possiamo ora convertire la data in formato timestamp. Questa operazione è relativamente semplice grazie alla funzione mktime:

A questo punto prima di inserire i dati dobbiamo connetterci al database utilizzando le funzioni viste in precedenza:

34


Quindi prepariamo una nuova query che questa volta dovrà occuparsi dell'inserzione:

Anche questa query è composta da più parti:

INSERT INTO news indica che vogliamo inserire un nuovo elemento nella tabella news La parentesi che segue indica in quali colonne vogliamo specificare il valore da inserire. Nel nostro caso specifichiamo tutte le colonne eccetto id, che verrà aggiornata automaticamente da MySQL.

Tramite VALUES indichiamo che ci apprestiamo a elencare i valori che vanno inseriti nelle colonne specificate in precedenza. Questi valori sono contenuti nella seconda parentesi e disposte nello stesso ordine con cui abbiamo specificato le colonne. Tutti i valori devono essere indicati fra due apici che possono essere omessi solo nel caso di valori numerici.

Questa query non richiede alcuna informazione al database, se non l'avvenuto inserimento, quindi anche qui possiamo verificare se l'inserzione è avvenuta:

Anche in questo caso abbiamo altre alternative per l'inserimento di nuove righe nel database. Possiamo per esempio utilizzare phpMyAdmin inserendo la query direttamente nella casella di testo "Esegui una/più query SQL sul database":

La stessa query può essere utilizzata per inserire l'articolo direttamente da una shell MySQL.

Da notare che in questi due casi abbiamo dovuto inserire tutti i valori all'interno della query, senza poter utilizzare le variabili come abbiamo fatto attraverso php. Questo può comportare alcuni problemi dovendo inserire campi di grandi dimensioni, come per esempio il nostro testo. Inoltre abbiamo dovuto calcolare manualmente la data in formato timestamp.

Dopo aver popolato il database con un certo numero di articoli, possiamo occuparci di visualizzarne i titoli. Ci occuperemo quindi di mostrare gli ultimi articoli, ordinati per data.

Prima di tutto creiamo, come sempre, la pagina che dovrà contenere i titoli inseriti. Questa pagina la

chiamiamo index.php visto che sarà la prima pagina dello script:

35


Visto che anche qui opereremo sul database dovremo come sempre connetterci utilizzando le funzioni già viste in precedenza:

A questo punto la query dirà a MySQL di selezionare gli ultimi articoli in ordine cronologico:

Questa query contiene molte delle possibilità che abbiamo a disposizione per la selezione di particolari righe dal database. Vediamole nel dettaglio:

SELECT id,data,titolo FROM news Questa prima parte è sempre necessaria quando vogliamo selezionare una o più righe. In particolare indica che a noi interessano solo le colonne id, data e titolo della tabella news.

Se avessimo voluto selezionare tutte le colonne, invece di indicarle tutte avremmo potuto usare la scorciatoia SELECT * FROM news. Se utilizzassimo solo questa parte della query, ci verrebbero restituite tutte le righe senza un particolare ordine. Questo perché non avremmo applicato nessun vincolo alla ricerca. I vincoli possono essere di diversi tipi e vengono specificati in seguito.

ORDER BY data DESC Aggiungendo questo verranno selezionate tutte le righe, ma in ordine di data. Visto che abbiamo aggiunto il parametro DESC la data verrà ordinata in modo decrescente. Quindi la prima riga della selezione sarà l'ultimo articolo inserito, la seconda sarà il penultimo e così via.

LIMIT 0,5 è il vincolo che limita la selezione a sole cinque righe. I due parametri da fornire rappresentano il primo elemento della selezione da cui partire (la numerazione parte da 0) e il numero di righe da selezionare.

Quindi aggiungendo questo vincolo limitiamo la selezione ai primi cinque elementi. Ci verranno quindi visualizzati solo gli ultimi 5 articoli inseriti.

Inviamo quindi la query al database e ne ricaviamo un identificatore nella variabile $result:

Attraverso $result, potremo ora ottenere le singole righe che ci vengono restituite dal database. Per fare questo utilizziamo la funzione mysql_fetch_array:

La funzione restituisce una sola riga del database in base alla selezione della query identificata da $result.

Una volta ottenuta la prima riga, sarà possibile ricavare la riga seguente richiamando nuovamente la funzione mysql_fetch_array. Quando le rige saranno finite, la funzione restituirà FALSE. Per

36


ottenere questo effetto abbiamo utilizzato while che esegue mysql_fetch_array ripetutamente finché ci saranno righe da visualizzare.

Da notare che se il nostro database contiene meno di cinque articoli, non abbiamo nessun problema, né per quanto riguarda la query, né per la visualizzazione. In seguito dovremo specificare in un blocco cosa vogliamo fare con la riga selezionata, prima di passare alla successiva:

Vediamo i singoli campi:

<a href=\"view.php?id=$row[id]\"> questa parte crea il link che permette all'utente di cliccare sul titolo per poter leggere tutto il contenuto. Questo link porta alla pagina view.php, che creeremo in seguito, passandogli come parametro l'id dell'articolo. Questo valore cambia da articolo ad articolo, quindi dovremo leggerlo dal database. Per questo abbiamo specificato nella query che ci interessava conoscere anche l'id dell'articolo.

Quindi lo stampiamo sotto forma di $row[id].

date("j/n/y", $row[data]) è una funzione Php che in base a una data in timestamp (nel nostro caso

memorizzato in $row[data]) crea la data nel formato g/m/aa. Questa la visualizziamo accanto al titolo.

- $row[titolo]</a><br> dopo aver inserito un delimitatore (nel nosto caso il meno -), visualizziamo il titolo, chiudiamo il tag del link e andiamo a capo.

Dopo aver visualizzato i cinque titoli, possiamo quindi chiudere la pagina:

Abbiamo appena visto come visualizzare i titoli degli ultimi articoli, attraverso i quali possiamo accedere ai testi completi. Vediamo quindi come possiamo accedere al contenuto di un articolo a partire dal solo id.

Creiamo quindi una nuova pagina che chiamiamo view.php che ha come unico scopo quello di visualizzare il testo completo di un articolo selezionato in precedenza nella pagina index.php. Anche a questa pagina diamo l'aspetto predefinito grazie alla funzione top():

Aggiungiamo inoltre la parte relativa alla connessione a MySQL:

Da notare a questo punto che attraverso il link che abbiamo creato nella pagina index.php, abbiamo passato un solo parametro. Questo parametro è l'id che caratterizza un solo particolare articolo nel database. Questo parametro resterà memorizzato nella variabile $id. Grazie a questa possiamo eseguire una query che ci permette di ricavare il contenuto e le caratteristiche dell'articolo. In questo caso la query sarà molto simile a quella vista in precedenza. Addirittura, visto che grazie all'id esatto richiederemo un solo articolo, non avremo bisogno di tutte le opzioni di ordinamento come nel caso della pagina index.php. La query da aggiungere in view.php sarà quindi:

37


Visto che dobbiamo selezionare una o più righe dalla tabella news, dovremo usare il comando SELECT e in particolare vogliamo avere tutte le colonne, tranne id. Tutto questo viene indicato con SELECT titolo,testo,data,autore,mail FROM news.

In questo caso abbiamo inserito un vincolo diverso, cioè abbiamo specificato tramite WHERE id='$id' che ci interessano solo gli articoli che hanno id esattamente uguale al valore contenuto nella variabile $id. Facendo così selezioniamo solo l'articolo di cui è stato cliccato il titolo nella pagina index.php. Non ci resta che ricavare i dati e visualizzarli:

In fondo all'articolo inseriamo due link: il primo porterà nuovamente alla prima pagina (index.php), il secondo aprirà una nuova pagina in cui verranno visualizzati i titoli di tutti gli articoli. Questa pagina si chiamerà all.php e la creeremo in seguito:

Infine chiudiamo la connessione al database e inseriamo la parte finale della pagina:

Vediamo adesso di riassumere le diverse modalità di gestione del database. Faremo particolarmente caso a quelle funzioni che devono essere utilizzate e ai parametri che devono essere specificati e quali invece possono essere omessi.

Abbiamo visto che prima di fare qualunque operazione con MySQL bisogna creare una connessione. Con questa indichiamo allo script dove si trova il nostro database e quali dati utilizzare. Come abbiamo visto la funzione è:

Questa funzione è sempre necessaria e deve essere, ovviamente, configurata correttamente tramite i tre parametri indicati sopra. Tutti e tre i parametri possono essere omessi. In questo caso i valori di default saranno localhost:3306 per il server (:3306 indica il numero della porta), username sarà quello del proprietario del database e la password sarà vuota. Visto che generalmente la password viene modificata per prima cosa dal gestore del server, risulterà impossibile effettuare una connessione senza indicare almeno gli ultimi due parametri. Ma visto che specificare un parametro ci obbliga a specificare anche tutti i precedenti, ci troviamo costretti quindi a specificare tutti e tre i

38


parametri quando lavoriamo on line. Tuttavia se si lavora in locale e non si ha indicato nessuna password al proprio MySQL (quello in locale), la connessione funziona anche senza i tre parametri. Questo è un frequente caso di errore quando si prova uno script in locale e funziona correttamente, ma una volta portato on line su uno spazio preso in hosting riceviamo una serie di errori.

Dopo la connessione selezioniamo un database:

Questa funzione può sembrare inutile, visto che nella maggior parte dei casi abbiamo a disposizione un solo database. Tuttavia non sempre è così, anzi, generalmente un singolo MySQL contiene diversi database, ma noi abbiamo accesso a uno solo di questi. Ovviamente dobbiamo specificare il primo parametro che conterrà una stringa con il nome del database che ci è stato assegnato dal gestore. Il secondo parametro indica la connessione attiva e può essere omesso, in quanto Php considera come identificatore di default l'ultimo creato. Visto che noi ne creiamo uno solo per pagina, non avrà problemi a identificare l'unico giusto. In realtà è possibile specificare il database in seguito ogni volta che invieremo una query, ma questa procedura è sconsigliata.

In seguito prepariamo la query e la inviamo al database:

Anche in questo caso possiamo omettere l'identificatore $db. Tutte le query possono essere suddivise in due categorie. La prima contiene tutte quelle che richiedono al database di restituirci determinati dati. Per esempio possiamo richiedere il contenuto di determinate righe di una tabella o il numero di record presenti in un'altra tabella. La seconda categoria comprende le query che richiedono a MySQL di apportare modifiche al database: inserimento di un record, eliminazione di una tabella, modifica di un insieme di record ecc.

Per tutte le query della seconda categoria non avremo bisogno di creare l'identificatore $result, visto che le modifiche vengono apportate subito.

Nel primo caso invece avremo bisogno di ricavare le informazioni che abbiamo richiesto in precedenza.

Questo lo facciamo usando la funzione:

Tramite questa funzione memorizziamo i risultati nell'array $row. $row può essere associativo con indice incrementale o entrambi. Questo lo scegliamo con in secondo parametro che può essere omesso. Vista la ridotta utilità di questa opzione, scegliamo di non utilizzare questo parametro.

Per poter ottenere tutte le righe richieste ci ricordiamo inoltre di inserire mysql_fetch_array all'interno di un ciclo while in modo tale da richiamarla finché non abbiamo esaurito i risultati.

Dopo aver eseguito tutte le operazioni, alla fine della pagina ci ricordiamo di chiudere la connessione al database:

Anche in questo caso possiamo omettere il parametro. Anzi, possiamo addirittura evitare di inserire la funzione stessa, come abbiamo già fatto in precedenza, visto che tutte le connessioni vengono chiuse automaticamente alla fine della pagina.

39


La struttura della Query

Vedremo adesso com'è costruita generalmente una query da inviare al database. Abbiamo visto precedentemente una suddivisione molto generica fra query che richiedono informazioni e query che invece indicano modifiche da apportare. In questa sezione faremo una distinzione più precisa indicando le query di uso più comune. Ovviamente non prenderemo in considerazione tutte le possibili sintassi, che potete però trovare nella documentazione ufficiale sul sito www.MySQL.com.

Innanzi tutto esaminiamo le query che vengono utilizzate per gestire la struttura del database:

CREATE: Tramite questo comando possiamo creare database e tabelle. Nel primo caso dobbiano solamente indicare il nome: CREATE DATABASE IF NOT EXISTS db_name

db_name indica ovviamente il nome che vogliamo assegnare al database, mentre l'opzione facoltativa IF NOT EXISTS evita che venga visualizzato un errore nel caso la tabella esista già. Da notare che nella maggior parte dei casi di hosting, ci viene assegnato un database dal gestore e non possiamo crearne altri. Tuttavia questa possibilità può essere comoda se possiamo gestire direttamente MySQL.

Per creare una tabella utilizziamo invece il generico comando:

CREATE TABLE IF NOT EXISTS tbl_name (definizioni)Anche qui abbiamo la possibilità di usare l'opzione IF NOT EXISTS. Le definizioni indicano i tipi di colonne di cui deve essere composta la tabella e la chiave primaria che verrà utilizzata. Abbiamo già visto queste caratteristiche prima per cui ora le omettiamo.

Per fare qualche esempio, una query per creare un database chiamato "mio_db" potrebbe essere:

Una volta impostate le operazioni su quel database, vi creiamo una tabella (my_table) nella quale inseriamo due colonne: la prima un contatore id e la seconda una colonna nome (stringa di 20 caratteri):

DROP: Così come abbiamo creato database e tabelle, li possiamo eliminare:

DROP DATABASE IF EXISTS db_nameDROP TABLE IF EXISTS tbl_nameE' consigliata la massima prudenza nell'usare questi comandi, visto che elminando un database o una tabella si elimina anche tutto il loro contenuto! Anche in questo caso IF EXISTS è facoltativo.

ALTER: Una volta creata una tabella, possiamo modificarla inserendo, rimuovendo o modificarndo colonne:

ALTER TABLE tbl_name ADD COLUMN definizioneCon una query di questo tipo aggiungiamo la colonna specificata in "definizione" alla tabella "tbl_name". La sintassi di "definizione" è uguale a quella usata per la creazione della tabella. In fondo al comando possiamo aggiungere FIRST se vogliamo che la colonna inserita sia la prima o AFTER column_name per assegnare una posizione diversa. Se non specifichiamo niente la colonna verrà inserita in ultima posizione.

Per fare un esempio inseriamo fra id e nome la colonna cognome:

40


Allo stesso modo possiamo eliminare una colonna:

Possiamo infine modificare il tipo di una colonna:

ALTER TABLE tbl_name MODIFY colonna new_type

INSERT: Una volta creato un database dovremo popolarlo inserendo i record:

INSERT INTO tbl_name (cols) VALUES (values)Anche di questa query abbiamo già visto la struttura precedentemente.

UPDATE: Tramite questa funzione possiamo modificare alcuni valori di determinate righe:

UPDATE tbl_name SET col_name=expr WHERE where_definitionQuesta notazione è piuttosto generale: tbl_name indica come sempre il nome della tabella, col_name=expr indica la modifica da apportare a una determinata colonna e where_definition indica le condizioni che si devono verificare in una riga perché questa possa essere modificata.

Per fare un esempio, possiamo assegnare il nome "Mario" a tutte le persone che hanno il cognome "Rossi":

Ovviamente possiamo indicare anche più condizioni tramite gli operatori OR o AND e possiamo indicare più modifiche.

DELETE: Per eliminare una o più righe ci basta indicare le condizioni che devono verificarsi:

DELETE FROM tbl_name WHERE condizioniAnche qui possiamo utilizzare condizioni composte:

SELECT: Questo genere di query è quella che si utilizza più spesso, in quanto servirà per ricavare i dati precedentemente inseriti in una tabella:

SELECT colonne FROM tbl_name WHERE condizioni opzioni.colonne indica tutte le colonne di cui vogliamo il valore. Queste possono anche essere operazioni.

condizioni sono le condizioni che devono verificarsi, perché una riga sia visualizzata. Queste sono dello stesso tipo di quelle viste nei casi UPDATE e DELETE.

opzioni ci serviranno per esempio per ordinare le righe.

Per fare un esempio:

41


Con questa query otterremo una tabella composta da quattro colonne. Le prime tre saranno quelle contenute nel database, mentre l'ultima conterrà un valore uguale per tutte le righe, cioè il numero di righe selezionate.

Se per esempio nel database ci sono 32 persone di cognome 'Rossi', allora quella colonna conterrà 32 volte il valore 32. Infine abbiamo indicato che le righe devono essere ordinate per nome e in caso di nomi uguali per id decrescente.

Se vogliamo per esempio sapere tutti i cognomi presenti nel database usiamo l'opzione GROUP BY, grazie alla quale le righe vengono raggruppate in base al loro contenuto in una colonna:

Utilizzando quest'opzione eviteremo di avere cognomi uguali ripetuti.

Come condizione possiamo anche utilizzare il metodo di confronto LIKE. Per esempio posso creare la query:

L'asterisco indica che voglio selezionare tutte le colonne. In seguito ho indicato di scegliere tutte le righe in cui il cognome inizi con "Ro" e finisca con qualunque sequenza di caratteri (indicata con il simbolo %),oppure il cui nome contenga "ri" (e possa quindi iniziare e finire con qualunque stringa).

Le principali funzioni PHP – My SQLVediamo quali sono le principali funzioni Php per interagire con MySQL:

mysql_affected_rows()Dopo aver inviato una query di modifica al database (INSERT, UPDATE, o DELETE) possiamo utilizzare questa funzione per ottenere il numero di righe su cui la modifica ha avuto effetto.

mysql_num_rows($result)Restituisce il numero di righe di cui è composto il risultato di una query. Questa funzione è valida solo per query del tipo SELECT.

mysql_insert_id()Dopo un inserimento, restituisce il valore utilizzato per la colonna di tipo AUTO_INCREMENT.

mysql_list_tables($nome_database)Restituisce una lista contenente i nomi delle tabelle nel database specificato.

mysql_escape_string($stringa)

42


Tramite questa funzione vengono inseriti i caratteri di escape nella stringa. Per fare un esempio, un utente potrebbe inserire in un form il suo username e password per visualizzare i suoi dati. Tramite alcuni accorgimenti potrebbe inserire dei valori particolari in modo tale da visualizzare i dati di un qualunque utente:

e con una query di questo tipo:

Potremmo evitare questo utilizzando mysql_escape_string:

La funzione non agisce sui simboli % e _ ed è stata inserita a partire dalla versione 4.0.3 di Php.

In Php possiamo nascondere gli eventuali errori ottenuti da una funzione, precedendo la stessa dal simbolo @. Questa particolarità non riguarda soltanto le operazioni MySQL, ma anche tutte le altre funzioni.

43


Zend 2.0

Introduzione

Sebbene la popolarità del linguaggio PHP sia costantemente in aumento, non mancano le perplessità sulla effettiva proponibilità di PHP per lo sviluppo di applicazioni complesse. Molta strada è stata percorsa dai tempi di PHP/FI, con un salto di qualità addirittura epocale quale è stato il passaggio dalla versione 3 alla 4 per giungere oggi ala versione 5. E' altrettanto indubbio, tuttavia, che c'è bisogno di proseguire nel miglioramento del linguaggio se si vuole evitare il rischio che rimanga relegato nel ruolo di "giocattolo" o poco più.

Fortunatamente qualcosa di molto interessante si sta sviluppando: la nuova generazione di Zend, il "motore" alla base del linguaggio, che promette innovazioni significative rispetto alla situazione attuale.

Alcuni problemi attuali

Prima di anticipare le novità del Zend 2.0, soffermiamoci su quegli aspetti critici del linguaggio.

Il primo è certamente il supporto limitato al paradigma object-oriented. Nonostante i miglioramenti introdotti in questa direzione da PHP4 (basato su Zend 1.0) rispetto alla precedente versione 3 (basata su Zend "0.5"), PHP rimane essenzialmente un linguaggio procedurale, con tutte le problematiche che ciò comporta. Scrivere codice PHP pulito non è semplice; se poi si ambisce alla riusabilità del software diventa ancor più evidente che, pur adottando il massimo rigore, non si riesce ad andare oltre un livello di complessità medio-basso.

Un altro aspetto critico è quello della mutevolezza di alcune caratteristiche del linguaggio: si pensi, ad esempio, alla gestione delle cosiddette variabili esterne modificata sensibilmente in almeno due occasioni. Questa particolare "instabilità", ulteriormente accentuata dal fatto che spesso cambiamenti anche di rilievo avvengono in occasione di minor releases, se non verrà in qualche modo arginata, rischia di dar vita ad innumerevoli micro-versioni di PHP, sottilmente (e diabolicamente) incompatibili fra loro. Il rischio, insomma, è che quello che oggi è buon codice, divenga domani un lavoro da rifare, in tutto o in parte.

Le due limitazioni sopra menzionate richiedono ovviamente soluzioni diverse. Tuttavia mentre per quanto riguarda la seconda possiamo solo auspicare a una stabilizzazione delle caratteristiche del linguaggio, per la prima ci sono buone notizie in arrivo. Possiamo, quindi, introdurre la prossima generazione di Zend.

La novità più importante di Zend 2.0 è il miglioramento del supporto per la programmazione object-oriented (OOP). Alla base delle nuove funzionalità vi è una riprogettazione del modello ad oggetti usato da PHP fortemente influenzata dal linguaggio Java.

44


Il nuovo modello ad oggetti

Zend 2.0, in particolare, introduce la gestione degli oggetti tramite handles, degli identificatori assimilabili a puntatori. Nella serie 1.x di Zend, invece, gli oggetti vengono trattati come valori del linguaggio al pari di stringhe, interi, etc.

Le conseguenze immediate di questa novità sono notevoli. Assegnare ad una variabile un oggetto significherà copiare in essa l'handle che lo identifica e non copiare l'intera istanza. Analogamente in caso di passaggio di un oggetto come argomento di una funzione sarà il solo handle ad essere fornito alla funzione stessa, evitando così una duplicazione inutile.

Fin qui si potrebbe avere l'impressione di non avere di fronte nulla di nuovo rispetto all'uso dei riferimenti (references) introdotti in PHP4. Risulta evidente il contrario se si considerano le possibilità inedite rese fattibili dal nuovo modello ad oggetti. Vediamone alcune.

Dereferenziazione. Il nuovo modello ad oggetti renderà possibili istruzioni del tipo $oggetto1->metodo1()->metodo2() dove metodo2() viene invocato rispetto all'oggetto restituito da metodo1(). Questa funzionalità, disponibile in molti linguaggi di programmazione, oltre ad essere di uso molto intuitivo, consente di scrivere codice più sintetico e previene alcuni tipi di errore.

Distruzione esplicita di oggetti. Mentre con l'attuale versione di Zend è impossibile deallocare un oggetto esplicitamente (la distruzione avviene automaticamente quando non vi sono più riferimenti ad esso), nel nuovo Zend ci sarà una funzione, delete(), che consentirà di distruggere un oggetto anche quando vi siano variabili che fanno riferimento ad esso.

Distruttori. Una classe potrà finalmente avere un distruttore, cioè un metodo che viene chiamato automaticamente prima della deallocazione di una istanza. Il metodo da usare come distruttore dovrà obbligatoriamente chiamarsi __destruct().

Tra le novità di Zend 2 ve ne sono altre di grande interesse che non discendono dal nuovo modello ad oggetti.

La più rilevante è sicuramente la possibilità di gestire le eccezioni, in modo simile a quanto avviene in Java ed altri linguaggi. I costrutti sintattici sono i classici try, throw e catch. Il primo viene utilizzato per racchiudere un insieme di istruzioni considerate "a rischio di eccezione"; se in tale blocco viene sollevata, con il costrutto throw, una eccezione, questa viene intercettata e gestita dal blocco catch più vicino. Il meccanismo delle eccezioni risulta particolarmente conveniente in quanto solleva il programmatore dalla fastidiosa necessità di gestire le possibili situazioni di errore istruzione per istruzione.

Altre due novità che dovrebbero essere introdotte (in questo caso, tuttavia, sembra che il team di sviluppo non abbia ancora preso decisioni definitive) sono l'ereditarietà multipla e le variabili private. La prima consiste nella possibilità di creare una classe ereditando funzionalità da più classi; attualmente è supportata solo l'ereditarietà singola (per cui una classe può estendere un'unica classe "madre"). La seconda novità riguarda la possibilità di dichiarare private delle variabili interne ad una classe (variabili membro, nel gergo dell'OOP), rendendole inaccessibili dall'esterno della classe stessa.

In definitiva le nuove caratteristiche di Zend dovrebbero rendere PHP un linguaggio più credibile per lo sviluppo di applicazioni web, ponendo rimedio (sia pure parzialmente) ad alcune gravi lacune che affliggono la versione attuale.

45

Indice degli argomenti - fabiofoggia.files.wordpress.com · Con PHP si possono fare non solo...

Documents

Transcript of Indice degli argomenti - fabiofoggia.files.wordpress.com · Con PHP si possono fare non solo...