No more maintained.
Now just a test in a lab.
Panoramica sulle funzioni di PHP
Riferimenti, esempi e teoria sulle funzioni che PHP fornisce
Funzioni in PHP
Tipo Infobox: DESCRIPTION - Skill:
L'utilizzo di funzioni è fortemente consigliato ogni qual volta si debba ripetere più volte una stesse serie di istruzioni, eventualmente su variabili diverse. Le ragioni sono sicuramente una migliore leggibilità del codice, una maggiore facilità nella manutenzione e una compattezza del codice.
In PHP la dichiarazione di una funzione è del tipo
function miafunzione(arg1, arg2, arg3=default3, ...)
{
... codice ...
}
Obbligatorie le parentesi graffe per la delimitazione del blocco di istruzioni che verrà eseguito all'invocazione della nostra funzioni. Si noti come ai parametri (opzionali) non sia necessario associare un tipo ma sia possibile invece indicare un valore di default nel caso non venga specificato il valore del parametro nell'invocazione. I parametri possono essere di ogni tipo, compresi quindi array e oggetti.
All'interno di una funzione riveste particolare importanza l'utilizzo del costrutto return ESPR dove ESPR può essere un espressione o una semplice variabile. L'istruzione (opzionale) di return permette di ritornare uno e un solo valore al chiamante, ovviamente quando si necessiti di avere come output della funzione diversi valori è possibile ritornare una variabile di tipo array che sarà poi gestita come tale dal chiamante, vediamo un esempio:
function miafunzione($a, $b)
{
$a = $a*10;
$b = $b*100;
return array($a,$b);
}
list($newa, $newb) = miafunzione(2,3);
Il passaggio dei parametri alla funzione può avvenire per valore (questo è il default), cioè la funzione crea internamente una copia della variabile passata e questa può essere modificata senza nessuna ripercussione sulla variabile originale, oppure per riferimento, tramite l'indicazione del simbolo & prima della variabile: in questo caso la funzione può modificare la variabile originale.
Questo codice può chiarire il concetto:
function quadrato($a)
{
$a *= $a;
}
$b = 2;
quadrato($b);
print 'valore: $b='. $b ."
\n";
quadrato(&$b);
print 'riferimento: $b='. $b;
Al contrario di altri linguaggi, in PHP non si può utilizzare le variabili globali per gestire in modo implicito le chiamate per riferimento, questo perchè in PHP le variabili globali non sono visibili all'interno delle funzioni a meno che siano indicate esplicitamente come tali all'interno della funzione tramite il costrutto global.
All'interno di funzioni è inoltre possibile dichiare delle variabili come static aventi cioè valenza (scope) locale alla funzione ma durata (lifetime) globale, questo ci permette di mantenere i valori della variabile in dichiarazioni successive alla funzione senza però esporla alla possbilitò di modifica inavvertita da altre componenti del nostro programma, cosa che sarebbe invece possibile se la avessi dichiarata come globale, di seguito un esempio classico per illustrare il concetto di variabile statica;
function allunga()
{
static $a='a';
return $a.='a';
}
$a = "b";
print allunga()."\n
";
print allunga()."\n
";
print allunga()."\n
";
print $a;
"require()" e "include()"
Tipo Infobox: DESCRIPTION - Skill: 2- JUNIOR
Sono funzioni che includono ed eseguono file specificati tra parentesi.
include("pagina");
require("pagina");
Possiamo, ad esempio, avere una pagina in cui è contenuto un ciclo while (chiamata while.php) e la pagina principale che la richiama (chiamata main.php).
Basterà aggiungere la linea include("while.php"); (o require) all'interno di main.php e il gioco è fatto.
La differenza sostanziale tra include() e require() è nel modo di gestire gli errori: include() produce un errore di tipo "Warning" mentre require() restituisce un "Fatal Error".
In pratica include() continuerà ad eseguire lo script nonostante l'errore, mentre un'errore trovato con require() blocca l'esecuzione della pagina.
Esiste un ulteriore funzione d'inclusione:
require_once("pagina.php");
Chiamando anche più volte nel codice della stessa pagina, questa funzione la includerà una sola volta.
Funzioni: come manipolare stringhe
Tipo Infobox: DESCRIPTION - Skill:
Dovendo mostrare all'utente finale i risultati di elaborazioni effettuate, eventulamente partendo da dati inseriti dallo stesso, risulta fondamentale sapere come gestire, modificare, validare i contenuti intesi come stringhe di caratteri.
Vediamo quindi quali sono le funzioni più utilizzate in tale ambito, partendo da quelle che ci permettono di inviare
banalmente l'output al client:
echo()
forse la prima istruzione che si impara, in effetti non è neanche definita come una vera e proria funzione
quanto come un costrutto del linguaggio, questo significa che le parentesi possono anche essere omesse, in questo caso
è possibile addirittura omettere il comando utilizzando una sintassi ridotta:
<?=$variabile?>
Altra funzione di stampa è
print()
anche in questo caso è possibile omettere le parentesi, come in
print "cuccuruccucu";
l'unica differenza rispetto alla echo è che print ritorna un valore che può essere testato per
verificare l'effettiva stampa della stringa così da potere inserirla in espressioni condizionali complesse.
Più potenti, e complesse, le funzioni
printf($formato, $argomenti), sprintf($formato, $argomenti)
che permettono di inserire all'interno della stringa $formato dei posizionatori tipizzati che verranno sostituiti dagli
argomenti presenti nella chiamata alla funzione.
Ad esempio
printf("Gentile cliente %s hai %u prodotti nel carrello", $cognome, $num_prod);
produrrà qualcosa del tipo
Gentile cliente Rossi hai 3 prodotti nel carrello"
La funzione sprintf() si differenzia solamente per il fatto che essa ritorna una stringa invece che
stamparla direttamente,il codice seguente ha lo stesso effetto dell'esempio precedente:
$stringa = sprintf("Gentile cliente %s hai %u prodotti nel carrello", $cognome, $num_prod);
echo stringa;
Anche se i problemi di spazio disco non sono più attuali spesso può essere necessario depurare una stringa (in specila modo
quelle inserite da un utente della nostra applicazione) da caratteri non necessari all'inizio o alla fine della stessa,
come ad esempio caratteri di blank.
I caratteri blank in PHP sono definiti essere le stringhe
- " " il classico spazio (ASC 32)
- "\t" il carattere di tabulazione (ASC 9)
- "\n" il carattere che definisice una nuova linea: line feed (ASC 10)
- "\r" l'a capo o meglio il carriage return (ASC 13)
- "\0" null cioè ASC 0
- "\x0B" la tabulazione verticale ASC 11
Le funzioni che puliscono le stringhe sono quelle della "famiglia" trim:
trim($stringa, $elenco_caratteri)
dove $elenco_caratteri è opzionale è può contenere gli ulteriori caratteri che si vogliono eliminare,
rimuove i caratteri non voluti all'inizio e alla fine della stringa.
ltrim($stringa, $elenco_caratteri)
left trim, in questo caso i caratteri verranno eliminati solo all'inizio della stringa
rtrim($stringa, $elenco_caratteri)
right trim, in questo caso invece i caratteri verranno eliminati solo alla fine della stringa
Ora che la nostra stringa contiene solo quello che vogliamo, potrebbe essere necessario fare in modo che i caratteri
speciali contenuti all'interno vengano gestiti da un escape. Per escape si intende la modifica di un carattere
perchè esso perda un suo significato particolare legato all'ambito applicativo e venga interpretato invece esattamente come
carattere, un esempio classico è quello degli slash.
PHP mette a disposizione la funzione
addslashes($stringa)
che restituisce $stringa avendo cura che ogni carattere che potrebbe recare problemi (ad esempio nell'esecuzione di $stringa
come una query su database) venga correttamente gestito anteponendovi un backslash.
I caratteri che verranno "escappati" sono
- l'apice '
- il doppio apice "
- backslash stesso \
- e il byte vuoto NUL
Per riportare la stringa al formato originale, facendo in modo cioè che sequenze del tipo "\\" ritornino ad essere "\",
si può utilizzare
stripslashes($stringa)
Questa risulta utile quando non si debba utilizzare la stringa "escappata" in un database ma, ad esempio,
la si voglia mostrare in output all'utente.
Una ulteriore accortezza è la codifica/decodifica dei caratteri speciali in entità HTML. Per entità HTML si intendono
quelle sequenze di caratteri preceduti da & che vengono utilizzati per indicare ai browser di visualizzare il
carattere speciale, alcuni esempi sono
"
&
€
La funzione
htmlentities($stringa)
converte automaticamente tutti i caratteri per i quali esiste una codifica HTML, mentre
htmlspecialchars($stringa)
converte solamente i caratteri &, ", ', < e >
La conversione opposta viene effettuata dalla funzione
html_entity_decode($stringa)
Passiamo ora ad analizzare le funzioni che ci permettono di operare sul contenuto della stringa per estarne dei sottoinsiemi di caratteri (sotto-stringhe)
o per verificare che all'interno della stringa appaiano particolari caratteri. Queste funzioni sono spesso usate in costrutti condizionali per effetuare
operazioni solo sulle stringhe che soddisfano particolari condizioni.
substr($stringa, $inizio, $lunghezza)
questa funzione ci permette, specificando oppurtanamente i parametri $inizio e $lunghezza (quest'ultimo non obbligatorio),
di estrapolare dalla stringa iniziale delle sequenze di caratteri, la cosa interessante è che oltre all'utilizzo intuitivo:
$stringa = "abcdefghilmnopqrstuvz";
print substr($stringa, 5);
che produrrà
fghilmnopqrstuvz
restituendo i caratteri a partire dal sesto fino al termine della stringa
oppure
print substr($stringa, 0, 10);
che produrrà
abcdefghil
estraendo i primi 10 caratteri a partire dal primo (si noti come, così come per gli array il primo carattere ha indice 0)
è anche possibile inserire numeri negativi come parametri, infatti nel caso l'indice di partenza sia negativo i caratteri verranno
presi a partire dal fondo della stringa, ad esempio
print substr($stringa, -5);
produce l'output
stuvz
tornando cioè gli ultimi cinque caratteri.
Nel caso sia negativo il parametro che indica la lunghezza il numero di caratteri ritornati sarà uguale al numero di caratteri
da $inizio alla fine della stringa meno il valore negativo di $lunghezza, vediamo degli esempi:
print substr($stringa, 0, -5);
torna
abcdefghilmnopqr
cioè i caratteri dalla prima pozione fino al sestultimo, mentre
print substr($stringa, 5, -5);
torna
fghilmnopqr
quindi dal sesto al sestultimo,
print substr($stringa, -5, -3);
produce
st
cioè a partire dal quint'ultimo carattere prendo i caratteri fino al terz'ultimo, si noti come (ovviamente) chiamate del tipo
print substr($stringa, -n, -n);
dove n è un intero producano sempre una stringa vuota.
Una funzione basata sugli stessi concetti di substr() è
substr_replace($stringa, $nuova, $inizio, $lunghezza)
che inserisce al posto della sottostringa individuata da $inizio e $lunghezza la stringa $nuovo,
così
print substr_replace($stringa, 'STUVZ', -5);
produce l'output
abcdefghilmnopqrSTUVZ
e invece
print substr_replace($stringa, 'ST', -5, -3);
produce l'output
abcdefghilmnopqrSTuvz
Un'altra possibilità per la redifinizione di una stringa è data da
str_replace($trova, $sostituisci, $stringa)
che sostituisce all'interno di $stringa tutte le occorrenze di $trova con $sostituisci,
ad esempio
$stringa="alfabeto alfanumerico";
print str_replace("alfa", "ALFA", $stringa);
ci mostra
ALFAbeto ALFAnumerico
attenzione che il match della sottostringa sarà case-sensitive cioè
$stringa="Alfabeto alfanumerico";
print str_replace("alfa", "AlFA", $stringa);
produrrà
Alfabeto AlFAnumerico
Solo dalla versione 5 di PHP è stato introdotta la funzione
stri_replace($trova, $sostituisci, $stringa)
che effettua un math case insensitive.
strpos($stringa, $cerca)
ritorna la posizione all'interno di $stringa del carattere o sottostringa $cerca oppure FALSE se
la sottostringa non è presente:
$stringa="Alfabeto alfanumerico";
print strpos($stringa, "fa");
ci mostra
2
indicandoci che la prima occorrenza di "fa" parte dal terzo carattere di $stringa.
Un problema comune si ha quando si utilizza questa funzione per verificare la presenza o meno della sottostringa,
infatti impostando il costrutto condizionale in questo modo
if (!strpos($stringa, "Al"))
print "Al (sembra) non esserci...";
incappiamo nel fatto che il PHP valuta la condizione !strpos($stringa, "Al") come FALSE dato che essa
vale 0 essendo che la stringa Al parte dall'indice 0 della stringa...
Per ovviare a questo problema si può utilizzare l'operatore di confronto === che indica un'uguaglianza non solo
nel valore ma anche nel tipo delle due variabili confrontate, il costrutto "giusto" sarà del tipo
if (strpos($stringa, "Al")===FALSE)
print "Al non c'è";
else
print "Al c'è";
Se ci interessa trovare invece l'indice dell'ultima occorrenza della sottostringa possiamo usare la funzione
right strpos:
strrpos($stringa, $cerca)
utilizzando l'esempio precedente
$stringa="Alfabeto alfanumerico";
print strrpos($stringa, "fa");
vediamo come il risultato sia diverso
11
Abbiamo visto come le stringhe in PHP siano molto vicine al concetto di array, è infatti possibile immaginare una stringa
come un array di caratteri indicizzati a partire da 0, possiamo infatti accedere al singolo carattere con modalità del tipo
$stringa = "abcdefghilmnopqrstuvz";
print $stringa{12};
che stampa il tredicesimo carattere di $stringa
o
Questa "vicinanza" tra stringhe ed array può essere ancora meglio compresa analizzando le funzioni che si occupano proprio
di permettere il passaggio tra una struttura "stringa" ad un "array" e l'inverso.
Partiamo da
explode($separatore, $stringa)
che ritorna un array con, in ogni elemento, la sottostringa ottenuta suddividendo $stringa in base al carattere o
sottostringa $separatore.
Vediamo un esempio
$stringa = "Mario Rossi studente";
$array = explode(" ", $stringa);
print "Nome: ".$array[0]."\n<br>";
print "Cognome: ".$array[1]."\n<br>";
print "Occupazione: ".$array[2]."\n<br>";
produce come output
Nome: Mario<br>
Cognome: Rossi<br>
Occupazione: studente<br>
Un utilizzo classico di questa funzione è il parsing di file di tipo CSV (Comma Separated Value) cioè di file che
contengono un record per riga, i campi del record sono separati da un carattere predefinito.
Si presti attenzione ai casi particolari in cui
- $separatore non sia presente all'interno di $stringa: il risultato della funzione sarà un array che contiene $stringa
- $separatore è una stringa vuota, in tal caso explode() ritorna il valore FALSE
L'operazione inversa, cioè partire da un array per ottenere una stringa è possibile con
implode($separatore, $array)
che genera la stringa unendo i vari elementi di $array con $separatore, così
$array = array("nome" => "Mario", "cognome" => "Rossi", "occupazione" => "studente");
$stringa = implode(",", $array);
print $stringa;
genera un riga che potremmo inserire in un file CSV:
Mario,Rossi,studente
E' anche possibile effettuare un suddivisione della stringa basandosi su un espressione regolae, la funzione che ce lo permette è
split($espressione, $stringa)
Questo può essere utile ad esempio quando la stringa sia inserita da un utente che può quindi utilizzare diversi separatori convenzionali, classico esempio
è quello dl reperimento del prefisso e del numero di telefono ad esempio:
$telefono1 = "335 12345678";
$telefono2 = "335-12345678";
$array1 = split ("[ -], $telefono1);
$array2 = split ("[ -], $telefono2);
print_r ($array1);
print_r ($array2);
Si noti come l'utilizzo di split() sia consigliato solo quando sia effettivamente necessario utilizzare espressioni regolari.
Funzioni: utilizzo di espressioni regolari
Tipo Infobox: DESCRIPTION - Skill:
Le Espressioni Regolari (RE) la cui sintassi è mutuata dal linguaggio Perl, permettono di effettuare operazioni di pattern marching e di traduzione su testi.
PHP offre una serie di funzioni per l'utilizzo di Espressioni Regolari (RE).
Le RE, mutuate dal linguaggio Perl, permettono di definire, tramite una particolare sintassi, un pattern
cioè una stringa variabile che verrà utilizzata dal "motore" (parser)
per verificare se all'interno di una stringa ci sia o meno una sequenza di caratteri che soddisfano la "maschera" richiesta.
Le RE si basano anche su una serie di modificatori che definiscono le modalità con cui il pattern verrà ricercato.
Prima di analizzare le funzioni per utilizzare le RE in PHP vediamo alcune indicazioni generali sull'utilizzo delle stesse:
per definire un pattern si utilizzano dei meta-caratteri, caratteri cioè che assumono particolari significati e che ci permettono
di delineare al meglio, anche se in un modo che può sembrare abbastanza complesso ad un primo acchito, la struttura della stringa
che vogliamo cercare:
\ è il carattere di escape che, prefisso ad un meta-carattere, indica di considerarlo come un carattere "normale" mentre
se anteposto ad alcuni caratteri identifica tipi di caratteri generici
^ indica l'inizio della stringa
$ indica la fine della stringa
. ha valore di qualsiasi carattere
? indica di considerare 0 o 1 del meta-carattere o gruppo di questi che segue
* indica di considerare 0 o più dei meta-carattere o gruppo di questi che segue
+ indica di considerare 1 o più dei meta-carattere o gruppo di questi che segue
importanza particolare ha l'utilizzo di parentesi
( e ) racchiudono un sotto-pattern
[ e ] racchiudono una definizione di un insieme di caratteri
{ e } racchiudono la definizione di un quantificatore in forma di intervallo di valori (min/max)
Giusto per complicare un po all'interno delle parentesi quadre alcuni di questi assumono un significato diverso:
^ se è il primo carattere indica la negazione della classe
- indica un range di caratteri
| indica una alternativa
I modificatori più utilizzati sono:
i indica che le lettere del pattern saranno confrontate in modo case-insensitive
m indica di considerare il pattern sempre è comunque come una sola riga,senza quindi "a capo"
La potenza delle RE nella gestione di testi è enorme, molti diranno "come la loro complessità", in questo ambito però
ci limitiamo a mostrare le funzioni che ci permettono di sfruttare le RE in PHP, contestualmente verranno dati alcuni esempi di semplici RE:
preg_match($pattern, $stringa, $matches)
Funzioni: gestione avanzata array
Tipo Infobox: DESCRIPTION - Skill:
PHP mette a disposizione del programmatore innumerevoli funzioni per la gestione delle variabili mantenute in
formato array che permette di avere un elenco di valori organizzati come chiave -> valore.
Innanzitutto per creare una struttura dati di questo tipo si utilizza
array()
ad esempio per creare una piccola rubrica $rubrica possiamo procedere in questo modo:
$rubrica = array (
"gino" => "0123456789",
"lino" => "987654321",
"tino" => "135792468");
Si noti l'utilizzo della sintassi indice => valore per associare ad un particolare indice
(numerico o stringa) un particolare valore.
Nel caso venga omesso l'indice allora i valori saranno indicizzati tramite una valore numerico incrementale,
si noti che in tale caso l'indice partirà da 0
Molto utile per verificare il valore degli array (e non solo) è la funzione
print_r ($variabile)
che restituisce in output una versione "leggibile" dell'array
Per ottenere un nuovo array con solamente gli indici dell'array iniziale:
array_keys($array)
tornando al nostro esempio l'istruzione
print_r (array_keys($rubrica))
avrà come risultato
Array
(
[0] => gino
[1] => lino
[2] => tino
)
In modo analogo si utilizza
array_values($array)
per avere un nuovo array in cui ci saranno gli stessi valori dell'originale ma indicizzati numericamente.
Quindi
print_r (array_values($rubrica))
ci mostrerà
Array
(
[0] => 0123456789
[1] => 987654321
[2] => 135792468
)
Nel caso ci serva solo verificare che il particolare indice sia presente nell'array, invece che scorrerlo
per intero, si può utilizzare la funzione
array_key_exists($indice, $array)
che ci restituirà TRUE nel caso in cui $indice sia presente come chiave in $array.
Per effettuare operazioni su ogni valore dell'array possiamo usare un semplice ciclo while
associato alla funzione
each($array)
ad esempio
while (list ($nome, $telefono) = each ($rubrica)
{
print "$nome ha telefono $telefono
";
}
ci mostrerà l'elenco completo presente nella nostra rubrica. Da notare come, prima di effettuare una eventuale
nuova lettura dell'array sia necessario riportare il puntatore al primo indice del nostro array, questo avviene utilizzando
la funzione
reset()
che restituisce anche il primo valore dell'array.
Le classiche funzioni POP e PUSH utilizzabili nella gestione di array come stack, cioè come una coda LIFO, sono
array_pop($array)
che estrae e restituisce l'ultimo valore di $array, riducendone quindi la lunghezza e
array_push($array, $elemento)
che aumenta la lunghezza di $array mettendovi in cima $elemento
Questo può esssere verificato contando gli elementi presenti nel nostro $array, facciamolo con
count($array) oppure sizeof($array)
che ritornano il numero di elementi presenti nell'array oppure 1 se la variabile passata non è un array oppure 0 nel caso di
count(NULL)
Questa veloce panoramica si chiude con le funzioni dedicate all'ordinamento degli array:
sort($array, $flag)
che ridispone gli elementi dell'array dal più piccolo al più grande, questo avviene ridefinendo gli indici,
attenzione quindi al fatto che gli indici originali verranno persi, tornando al nostro esempio
sort($rubrica);
print_r ($rubrica);
avrà come risultato;
Array
(
[0] => 0123456789
[1] => 135792468
[2] => 987654321
)
è possibile definire la modalità di comparazione fra gli elementi tramite l'impostazione di $flag
sort($array, SORT_REGULAR): default, vengono comparati in modo normale
sort($array, SORT_REGULAR): default, vengono comparati in modo numerico
sort($array, SORT_REGULAR): default, vengono prima convertiti in stringhe e poi comparati
rsort($array, $flag)
reverse sort si comporta come sort solo che gli elementi verrano disposti in ordine inverso
asort($array, $flag) e arsort($array, $flag)
sono le funzioni di ordinamento che permettono di mantenere l'associazione del valore con l'indice originale
asort($rubrica);
print_r ($rubrica);
avrà come risultato;
Array
(
[gino] => 0123456789
[tino] => 135792468
[lino] => 987654321
)
--> array_map()
--> get_object_vars
date
Tipo Infobox: COMMANDS - Skill:
Funzione che formatta la data e l'ora.
date("[argomenti]")
ARGOMENTI (i più usati):
a stampa "am" o "pm"
A stampa "AM" o "PM"
d stampa il giorno del mese in formato numerico in 2 cifre (da "01" a "31")
D stampa il giorno della settimana in formato testuale abbreviato a 3 lettere (es. "Mon")
F stampa il mese in formato testuale (es. "January")
h stampa l'ora nel formato a 12-ore (es. da "01" a "12")
H stampa l'ora nel formato a 24-ore (es. da "00" a "23")
i stampa i minuti (es. da "00" a "59")
I (I maiuscola) stampa "1" se c'è l'ora legale, "0" se c'è quella solare
l (L minuscola) stampa il giorno della settimana in formato testuale non abbreviato (es. "Monday")
L stampa "1" se l'anno è bisestile, "0" altrimenti
m stampa il mense in formato numerico (es. da "01" a "12")
M stampa il mese in formato testuale abbreviato a 3 lettere (es. "Jan")
s stampa i secondi (es. da "00" a "59")
Y stampa l'anno nel formato a 4 cifre (es. "2002")
y stampa l'anno nel formato a 2 cifre (es. "02")
es. echo date ("l F Y h:i:s A"); darà come risultato Thursday October 2002 3:35:40 PM
mktime
Tipo Infobox: COMMANDS - Skill:
Restituisce la UNIX timestamp per una data. Questa timestamp è un intero lungo (longint) contenente il numero di secondi tra la Unix Epoch (ossia "January 1 1970") e la data e orario specificati. E' usata per fare calcoli tra date.
Viene usato in combinazione con date
mktime ( int hour, int minute, int second, int month, int day, int year)
Vediamo un esempio: echo date ("M-d-Y", mktime (0,0,0,8,10,02));
con il comando mktime (0,0,0,8,10,02) viene indicata la data da esaminare (le 00:00:00 del 10 ottobre 2002) e con il comando echo date ("M-d-Y") viene detto come trattare la data e l'ora appena calcolata. Alla fine verrà stampata la stringa Oct-10-2002.
L'ultimo giorno del mese viene espresso come il giorno "0" del mese successivo.
Ad esempio: echo date ("d M Y", mktime (0,0,0,10,0,02)); indica l'ultimo giorno del mese di Settembre 2002. Verrà quindi stampato 30 Sept 2002
mail()
Tipo Infobox: COMMANDS - Skill:
Funzione che permette l'invio delle mail tramite php.
mail($mail, $subject, $message, $headers);
$mail indirizzo a cui viene inviata la mail. per inviare la mail a più destinatari basta separare ogni indirizzo con una virgola. ATTENZIONE: usate con moderazione, evitate di fare spam
$subject titolo della mail inviata
$message corpo della mail
$headers sono informazioni aggiuntive alla mail (come ad esempio l'indirizzo di chi la invia, delle copie carbone o delle copie nascoste).
La funzione mail funzione anche se non viene specificato alcun header. Se non si precisa l'indirizzo di chi la invia (il From negli headers), come indirizzo di provenienza viene visualizzato NOME_SERVER@DOMINIO.
Ecco un banalissimo esempio:
mail("[email protected]", "Ciao", "Questo è una prova", "From: Max_Rispetto <[email protected]>");
In questo caso viene spedita una mail all'indirizzo "[email protected]" con titolo "Ciao" e testo "Questo è una prova" inviata da "Max_Rispetto" con indirizzo "[email protected]"
Vediamo ora un esempio un po' più complesso, ossia come utilizzare la funzione mail in combinazione con un form di richiesta dati.
Ipotizziamo di dover gestire una newsletter. In una pagina vengono richiesti alcuni dati anagrafici di chi si vuole iscrivere e, una volta completata l'operazione, verrà inviata una mail di conferma.
Bisogna creare due pagine php, una chiamata form.php (in cui verranno immessi i dati) e una chiamata send.php (in cui si gestirà la spedizione vera e propria della mail).
Cominciamo con la pagina form.php:
<html>
<body>
<form name="form" method="post" action="send.php">
Inserisci il nome <input type="text" name="nome">
Inserisci la mail <input type="text" name="mail">
</form>
</body>
</html>
Ricordarsi di far puntare il form alla pagina send.php!
Creiamo ora la pagina send.php:
<html>
<body>
<?php
$from="[email protected]";
$titolo="Benvenuto!";
$testo="Ciao $nome. Ti sei iscritto alla newsletter.";
mail($mail, $titolo, $testo, "From: $from");
?>
</body>
</html>
Da notare: ho preparato in anticipo i campi $titolo e $testo, in modo da snellire la funzione mail.
Questo è tutto: con queste due paginette abbiamo un semplice sistema di invio mail. Naturalmente i più esperti possono utilizzare una sola pagina sia per fare il form che per inviare la mail.
Funzioni: protocollo HTTP
Tipo Infobox: DESCRIPTION - Skill:
Queste funzioni, utili solamente nel caso si lavori in ambito web, permettono di inviare al browser dati a livello
di header HTTP quindi precedenti al contenuto della pagina generata.
Oltre che il semplice output a livello di codice HTML (ad esempio) è possibile inviare la browser dell'utente anche dei dati
che verranno gestiti come HTTP headers, è possibile cioè, assolutamente prima di inviare ogni altro contenuto, indicare al
browser di effettuare una redirezione oppure assegnargli dei cookie, vediamo quali sono le funzioni che possiamo utilizzare:
header($stringa)
invia al browser la direttiva contenuta in $stringa
l'utilizzo più comune di questa funzione è la redirezione, impostando correttamente $stringa è possibile indicare
al client di effettuare una nuova richiesta al server ad esempio
header("Location: http://www.google.com/");
redirigerà il browser alla home di Google, si noti come l'invocazione della funzione debba essere necessariamente la prima istruzione
della pagina e come, ovviamente, questa non abbia nessuna utilità nel caso si stia realizzando una applicazione non web.
Un altro utilizzo molto interessante è la possibilità di indicare al browser il MIME Type del flusso che si sta generando, quando
questo sia diverso da HTML, in modo che il browser predisponga il plugin necessario alla visualizzazione e si comporti in pratica come
se stesse effettuando un download di un file statico e non generato on-the-fly dalla pagina PHP:
header("Content-type: application/pdf");
header("Content-Disposition: attachment; filename=documento_".$data_di_oggi.".pdf");
readfile("documento.pdf");
purtroppo questo tipo di codice sembra avere problemi con alcune versione di Internet Explorer per cui l'utilizzo su siti pubblici
va attentamente valutato.
setcookie($nome, $valore, ...)
questa funzione, come al solito richiamta come prima funzione della pagina, invia al browser un cookie di cui è possibile definire
oltre al $nome e $valore (opzionale) anche una serie di altri parametri come:
$scadenza: la data, in formato UNIX timestamp, in cui il cookie scadrà, spesso per indicare un cookie non permamente si
usa impostare questo parametro ad una data già passata.
$percorso: le directory del domino web in cui il cookie sarà valido, indicando ad esempio /shop/ il cookie in questione sarà
considerato sono quando si richiamino URL del tipo www.domino.com/shop e non ad esempio nella root
$domino: serve per fare in modo che il cookie sia valido anche in sottodomini di quello che lo ha rilasciato, indicando ad esempio .domino.com
il cookie sarà valido non solo in www.dominio.com ma anche in shop.dominio.com oppure in prodotti.dominio.com
$sicuro: se impostato a 1 indica che il cookie sarà trasmesso solo in condizioni di connessione protetta (HTTPS).
Dalla descrizione delle funzioni si può notare come molti comportamenti siano strettamente legati al tipo e alla versione del browser,
questo può spesso portare a comportamenti imprevisti dell'utilizzo non banale delle funzioni.
Funzioni: gestione di variabili di sessione
Tipo Infobox: DESCRIPTION - Skill:
L'utilizzo di variabili di sessione permette di mantenere informazioni legate all'utente che sta visitando le nostre pagine. Vediamo quali funzioni possiamo utilizzare a riguardo
Il concetto di sessione definisce una tecnica
che permette di mantenere il valore di alcune variabili legate al particolare utente durante gli accessi a diverse
pagine. Questo "arteficio" nasce dal fatto che, come noto, il protocollo HTTP utilizzato per la richiesta di risorse ad
un web server è state-less cioè ogni richiesta è indipendente dalla altre così per potere seguire il percorso dell'utente
attraverso diverse pagine non rimane che "rimbalzare" tra esse delle variabili nascoste oppure utilizzare le funzioni predisposte
che in definitiva fanno proprio quello agevolando però il compito del programmatore.
PHO utilizza un espediente comune a molti linguaggi web cioè lega un cookie temporaneo all'utente, questo permette
di identificarlo univocamente e quindi mantenere "vive" le variabili che sono state associate. Oltre ciè quando il client
non permetta l'utilizzo di cookie viene applicato un sistema automatico di "URL rewriting" per cui ad ogni link viene associato
un parametro supplementare che, proprio "rimbalzando" tra le pagine accedute, svolge la stessa funzione del cookie.
Per potere usufruire dell'array associativo superglobale $_SESSION che ci servirà per registrare le nostre variabili
permanenti è necessario prima di generare qualsiasi tipo di output e in ogni pagina in cui si usa $_SESSION richiamare la funzione:
session_start()
la necessità di inserire questa funzione come prima istruzione nelle nostre pagine è data dal fatto che la definizione
dei cookie avviene a livello di "header HTTP" che vengono inviati al client proprio prima di ogni altro contenuto, per verificare
questa limitazione proviamo questo semplice codice:
print "prima io";
session_start();
si ottiene qualcosa del tipo
prima io
Warning: session_start(): Cannot send session cookie - headers already sent by (output started at C:\Apache2\htdocs\test.php:7) in C:\Apache2\htdocs\test.php on line 9
l'utilizzo corretto ci permette invece di utilizzare le variabili registrate anche in pagine successive:
uno.php:
session_start();
$_SESSION['msg']='sei passato da uno.php';
print "<a href='due.php'>vai a due.php</a>";
due.php
session_start();
isset($_SESSION['msg'])?print $_SESSION['msg']:print "NON sei passato da uno.php";
Si provi ad accedere a uno.php e a cliccare sullink per due.php, successivamente, avendo cura di annullare la sessione (si può fare chiudendo
il browser) si acceda direttamente a due.php.
Per annullare una variabile di sessione è sufficiente
unset($_SESSION[$variabile])
si provi ad esempio notando l'errore che viene generato
session_start();
$_SESSION['msg']='qua';
print $_SESSION['msg']."<br>\n";
unset ($_SESSION['msg']);
print $_SESSION['msg']."<br>\n";
date le peculiarità della funzione session_start() essa viene spesso inserita come prima comando all'interno di un file
(ad es: config.php) che verrà incluso all'inizio di ogni pagina dell'applicazione.
A volte, ad esempio quando si voglia mantenere una traccia permanente (quindi non legata solo alla sessione) dell'utente
in un file oppure in un database, può essere utile associare l'utente alla stringa univoca (session id) generata da PHP,
per recuperare questa stringa si usa
session_id()
Se nei successivi accessi si vuole che l'utente "riacquisti" la sessione originale è possibile farlo, prima di invocare
session_start() passando il session id alla funzione:
session_id($old_session_id)
vedere i cookies
Tipo Infobox: TIPS - Skill:
In PHP esiste una variabile superglobale che contiene l'elenco dei cookie che arrivano alla pagina
La variabile $_COOKIE accessibile ovunque in una pagina PHP permette di accedere in forma di array ai cookie inviati al browser.
Per esempio, avendo inviato un cookie tramite le funzione:
setcookie ('TitoloCookie', "Qua c'e' il contenuto del cookie", time()+60*60*24*365, '/');
si potra' accedere al cookie semplicemente tramite la variabile:
$_COOKIE['TitoloCookie']
Funzioni: il file system
Tipo Infobox: DESCRIPTION - Skill: 3- INTERMEDIATE
Utilizzando php si possono compiere parecchie operazioni interessanti sui file (copiarli, spostarli, moificarli, etc.).
La prima cosa da capire è che non si lavora realmente su un file, ma sul suo puntatore. In pratica il puntatore è un numero intero non negativo (non è assolutamente inportante il valore che assume) che viene utilizzato per riferirsi al file preso in considerazione.
In genere il puntatore viene chiamato $fp (File Pointer) o $fd (File Descriptor), ma si può anche cambiare nome.
La funzione che assegna un file ad un puntatore è la seguente:
fopen (nome_file, mode)
Il modo di apertura del file può essere:
r: apre il file in sola lettura e posiziona il puntatore all'inizio del file. Se il file non esiste, viene visualizzato un errore.
r+: apre il file in lettura e scrittura e posiziona il puntatore all'inizio del file. Se il file non esiste, viene visualizzato errore.
w: apre il file in sola scrittura, posiziona il puntatore all'inizio del file e tronca il file a lunghezza zero (ossia sovrascrive le informazioni contenute nel file). Se il file non esiste, prova a crearlo.
w+: apre il file in lettura e scrittura, posiziona il puntatore del file all'inizio del file e tronca il file a dimensione zero (ossia sovrascrive le informazioni contenute nel file). Se il file non esiste, tenta di crearlo.
a: apre il file in sola scrittura e posiziona il puntatore alla fine del file. Se il file non esiste, prova a crearlo.
a+: apre il file in lettura e scrittura e posiziona il puntatore alla fine del file. Se il file non esiste, prova a crearlo
Nel caso si lavori su sistemi Windows, allora esiste anche il modo b: in questo modo il file viene considerato come binario e non come file di testo. I sistemi Unix invece non fanno differenza tra file binari e di testo.
Vediamo qualche esempio:
$fp=fopen("/home/max/elenco.txt", "r");
Apre in lettura il file elenco.txt contenuto nella cartella /home/max. Questo funziona su sistemi Unix: notate la differenza con l'esempio seguente, fatto su sitema Windows
$fp = fopen ("c:\\max\\elenco.txt", "r");
Apre in lettura il file elenco.txt contenuto nella cartella max sul disco fisso c:. Questo funziona su sistemi Windows.
$fp=fopen("http://openskiss.info/elenco.txt", "r");
Il comando fopen apre anche file residenti su altri host. In questo caso il file è elenco.txt presente su openskills.info
Una volta aperto un file si possono compiere numerose operazioni sullo stesso. Si può leggere un carattere alla volta, leggere una riga alla volta, leggere l'intero file, scrivere sul file, chiudere il file.
Vediamo le funzioni nel dettaglio:
fgetc($fp): legge un carattere alla volta e restituisce una stringa contenente un solo carattere. Restituisce FALSE se incontra la fine del file (EOF ossia End Of File).
fgets($fp, lunghezza_stringa): legge una stringa di lunghezza definita da (lunghezza_stringa-1) byte. La lettura termina anche quando viene raggiunta la fine della linea o la fine del file (EOF). Se non viene specificata nessuna lunghezza, allora di default viene impostato 1024 byte.
fread($fp, lunghezza_stringa): esattamente come fgets, solo che anzichè leggere (lunghezza_stringa-1) byte legge esattamente lunghezza_stringa byte. Non si ferma se raggiunge la fine di una riga, ma solo se finisce i byte impostati o se raggiunge la fine del file.
readfile(nome_file): apre il file specificato, lo legge, lo stampa in formato standard output e restituisce il numero di byte letti dal file. Se si verifica un errore viene resituito FALSE: per evitare errori è sufficiente aggiungere il carattere @ davanti a readfile.
fputs($fp, stringa, lunghezza_stringa): scrive sul file puntato da $fp il contenuto di "stringa" (oppure, se specificato, i primi "lunghezza_stringa" byte).
fwrite($fp, stringa, lunghezza_stringa): uguale a fputs.
feof($fp): verifica se il puntatore ha raggiunto la fine del file. In caso positivo (o anche in caso di errore) restituisce TRUE, altrimenti FALSE.
fclose($fp): una volta terminato l'utilizzo, chiudere sempre il file. Restituisce TRUE in caso di successo e FALSE in caso di errore. I file vengono comunque chiusi automaticamente alla fine dello script.
Vediamo ora qualche semplice esempio:
$fp = @fopen("http://openskills.info/index.php","r");
if ($fp)
{ echo "Il file esiste!"; }
else
{ echo "il file non esiste"; }
Abbiamo aperto in lettura il file index.php su openskills.info: se il file viene trovato viene stampato un messaggio di conferma. Abbiamo usato il simbolo @ davanti a fopen per evitare strani errori che possano bloccare lo script.
$fd = fopen ("/tmp/inputfile.txt", "r");
while (!feof ($fd)) {
$buffer = fgets($fd, 4096);
echo $buffer;
}
fclose ($fd);
Classico esempio di lettura file riga per riga. Il file viene aperto in lettura (usando fopen); a questo punto viene fatto ciclare: finchè non viene raggiunta la fine del file (usando feof) viene memorizzata ciascuna riga in una variabile chiamata $buffer, che viene successivamente stampata. Alla fine il file viene chiuso (fclose).
$fp=fopen("prova.txt","w");
fputs($fp, "Prova inserimento testo");
Il file prova.txt viene aperto in lettura e scrittura (se non esiste viene creato, se invece esiste viene "troncato" il suo contenuto) utilizzando fopen. A questo punto all'interno del file viene scritta la stringa "Prova inserimento testo" usando fputs.
Funzioni: directory
Tipo Infobox: DESCRIPTION - Skill:
Così come quando si lavora con file è possibile "maneggiare" directory tramite l'utilizzo di handle.
opendir($path)
restituisce un identificatore della risorsa (handle) associato al percorso passato come parametro, attenzione
che se il percorso non è valido oppure non si hanno i permessi di navigazione della particolare cartella verrà generato un errore
e il valore ritornato sarà FALSE
closedir($handle)
chiude la risorsa aperta precedentemente
readdir($handle)
ritorna il nome del file successivo nell'elenco della directory identificata da $handle. L'ordinamento dei file è quello
del file system. Nel caso classico in cui si voglisa scorrere tutti i file presenti in una directory è necessario prestare attenzione
alla corretta condizione da utilizare nel ciclo:
while (FALSE !== ($nome_file = readdir($handle))
{
print "$nome_file<br />";
}
si noti l'utilizzo dell'operatore di confronto !== che ritorna TRUE nel caso in cui i le due variabili siano diverse come valore
oppure se non siano dello stesso tipo, in questo modo viene bypassato il problema dell'uscita dal ciclo nel caso ci fosse un file
con un nome valutato da PHP come FALSE: ad esempio '0'.
rewinddir($handle)
riporta il puntatore della risorsa al primo elemento, è utile quindi quando si debba navigare diverse volte la stessa directory per
evitare di generare ogni volta un handle diverso
Per rendersi conto della directory in cui si sta lavorando si può utilizzare
getcwd()
che restituisce la directory di lavoro in unso al momento della chiamata
La directory di lavoro può essere modificata tramite
chdir($path)
Funzioni: eseguire comandi shell
Tipo Infobox: DESCRIPTION - Skill:
In particolari condizioni di configurazione: quando cioè non sia disabilitata shell_exec e non sia abilitata
la direttiva safe_mode, è possibile esguire dei comandi shell direttamente da uno script PHP.
Addirittura usando l'operatore di esecuzione denominato backticks (apice contrario in una brutta traduzione): ``.
In pratica è possibile catturare facilmente in una variabile l'output di un comando shell con una sola riga di script, ad
esempio
$data_server = `date`;
print "Data sul server: $data_server";
lo stesso risultato, probabilmente con codice più leggibile, è ottenibile tramite la funzione
shell_exec($comando)
il nostro semplice esempio potrà anche essere quindi:
$data_server = shell_exec('date'); // notare gli apici
print "Data sul server: $data_server";
PHP mette a disposizione almeno altre 3 funzioni per l'iterazione con la shell, ognuna di queste con carattestiche particolari
legate per lo più alla gestione del risultato dell'elaborazione. In ogni caso è SEMPRE raccomandabile utilizzare
escapeshellcmd($comando)
oppure
escapeshellarg($comando)
per evitare che i parametri, eventualmente forniti da un utente, da utilizzare nel comando shell, contengano codice eseguibile.
exec($comando, $ritorno_array, $ritorno_valore)
esegue $comando non inviando direttamente nessun output ma ritornando l'ultima riga del risultato.
Il parametro opzionale $ritorno_array conterrà tutte le righe dell'output del comando, una per ogni suo elemento,
$ritorno_var opzionale pure esso, conterrà il lo stato del comando: 0 corrisponde a "comando eseguito correttamente"
system($comando, $ritorno)
esegue il comando shell contenuto in $comando restituendo l'ultima riga dell'output generato oppure FALSE in caso di fallimento,
se è presente il parametro $ritorno allora lo stesso verrà valorizzato con il codice di stato ritornato dal comando, ad esempio
$data_server = system('date', $ritorno);
print "Data sul server: $data_server<br>";
print "Ritorno: $ritorno<br>";
A differenza di exec() quindi il risultato del comando viene minviato direttamente al browser.
sul brower.
infine
passthru($comando, $ritorno)
invia direttamente al browser l'output generato da $comando senza intervenire in alcun modo su essi.
Questa funzione è molto utile ad esempio quando si generino dei file binari (immagini o altro) tramite comandi shell
e li si volgia inviare direttamente al browser.