Questa guida rappresenta una riscrittura aggiornata della Guida Teorica a PHP scritta da Edoardo Valsesia

Il PHP, durante il processo di inizializzazione, crea delle variabili speciali (chiamate variabili superglobali) che contengono diversi tipi di informazione e che mi appresterò a trattare tra poco. Queste variabili sono accessibili da qualunque posizione dello script ed hanno dei nomi riservati che non andrebbero sovrascritti se non in casi particolari. Le variabili in questione sono:

A fronte di tutto questo è importante ricordarsi di non sovrascrivere questi valori, dato che sono spesso fondamentali per la corretta esecuzione dello script.

Le funzioni sono una delle parti più importanti di un linguaggio di programmazione, perchè permettono di eseguire determinate operazioni all'interno di uno script.

Le funzioni messe a disposizione dal PHP sono moltissime, e vederle tutte sarebbe inutile; ci soffermeremo invece su quelle più importanti ordinate alfabeticamente.

$num = -3.4;
$aa = abs($a);
echo $aa, "\n";

$arg = 1;
$arc_cos = acos($arg);
echo "$arc_cos\n";

base64_decode: decodifica una stringa codificata in MIME base64 (vedi sotto);

$str = "Ciao, io sono pippo\n";
echo "$str\n";
$enc_str = base64_encode($str);
echo "$enc_str\n";
$dec_str = base64_decode($enc_str);
echo "$dec_str\n";

si passa allo script la stringa "$str" che viene prima codificata e visualizzata, poi decodificata e nuovamente visualizzata;

basename: restituisce, dato un percorso, la componente di questo identificata da un nome di file; ad esempio:

$path = "/var/www/php/index.php";
$base = basename($path);
echo "$base\n";

$num = bcadd(1.334, 4.44554, 2);
echo "$num\n";

restituirà 5.77; la funzione "bcadd" prende come primi due argomenti due numeri e, come terzi argomento opzionale, il numero di cifre da visualizzare dopo la virgola;

bccomp: compara due numeri: la funzione prende come argomento due numeri e, opzionalmente, un ulteriore numero che determina il numero di decimali da considerare dopo la virgola per considerare i due numeri uguali; restituisce "0" nel caso i due numeri siano uguali, "+1" se il numero di sinistra è maggiore di quello di destra e "-1" nel caso opposto. Considerate il seguente esempio:

$comp = bccomp(0.334, 0.301, 2);
echo $comp;

che restituirà "1"; ma se, al posto del "2" avessimo inserito uno oppure non avessimo inserito niente, il risultato sarebbe stato "0".

bcdiv: divide due numeri, con le stesse modalità descritte per "bcadd" e "bccomp";

bcmult: moltiplica due numeri, ed è possibile aggiungere un ulteriore parametro per limitare il numero di cifre dopo la virgola:

$molt = bcmul(2.31, 3.21, 2);
echo "$molt\n";

bcpow: eleva a potenza due numeri, con la possibilità di specificare il numero di cifre dopo la virgola:

$pot = bcpow(2.3, 3, 2);
echo "$pot\n";

eleverà 2.3 alla terza potenza, approssimando il risultato alla seconda cifra decimale;

bcsqrt: calcola la radice quadrata di un numero, con la possibilità di approssimare il numero di cifre dopo la virgola aggiungendo un secondo elemento alla funzione (come avveniva per altre funzioni matematiche viste sopra;

bcsub: sottrae un numero da un altro, anche qui con la possibilità di approssimare le cifre dopo la virgola:

bin2hex: converte una stringa di dati dal formato binario a formato esadecimale;

ceil: restituisce il valore intero più alto riferito al numero passato come argomento alla funzione:

restituisce TRUE se l'operazione ha successo, FALSO in caso contrario, ad esempio nel caso la directory non sia leggibile;

checkdate: controlla che una data sia valida; per considerarsi valida, una data deve avere:

chgrp: tenta di cambiare il gruppo di un file a "gruppo"; la funzione accetta come argomenti il nome del file a cui si vogliono cambiare i permessi ed il nuovo gruppo di appartenenza:

chmod: è equivalente al comando di sistema Unix "chmod" ed ha la stessa sintassi di chgrp;

chmop: rimuove i "whitespaces" da una stringa; spesso è utilizzato per eliminare i caratteri "\n" quando si riceve un argomento dallo standard input; il carattere eliminato può essere letto con:

chown: cambia il proprietario di un file, come l'analogo comando di sistema Unix. Accetta come argomento il nome del file ed il nome del nuovo proprietario:

Nei sistemi Windows, non fa niente e restituisce sempre vero (ed è peraltro inutile inserire questa funzione all'interno di uno script che non supporta il comando "chown");

chr: restituisce il carattere ASCII specificato dal rispettivo numero; immagino sappiate, ad esempio, che la combinazione "Alt + 0126" restituisce la tilde (~); lo si può vedere con il seguente codice:

chunk_split: divide una stringa in parti di "n" caratteri; il numero è passabile alla funzione dopo la stringa da dividere. Se non impostato, di default è assunto come 76; l'esempio

$string = "Questo è un corso per imparare il linguaggio php":
$split = chunk_split($string, 5);

La funzione è utile per l'encoding MIME base64 visto precedentemente con la funzione base64_encode;

closedir: chiude una directory precedentemente aperta con la funzione opendir() - vedi;

$arr[0] = "abc";
$arr[1] = "def";
$arr[2] = "ghi";
$count = count($arr);
echo $count;

restituirà "3", visto che all'interno dell'array "$arr" sono presenti 3 elementi ($arr[0], $arr[1], $arr[2]);

In pratica, dovremo passare alla funzione la stringa che dovrà essere crittata e, opzionalmente, il seme con sui crittarla; se questo non è passato alla funzione, sarà generato in maniera random dal PHP stesso. Un esempio di crittazione di una stringa potrebbe essere il seguente:

$arr[0] = "abc";
$arr[1] = "def";
$arr[2] = "ghi";
$current = current($arr);
echo $current;

date: visualizza la data in formato che è possibile definire; la funzione riconosce come validi i seguenti formati:

a: am/pm;
A: AM/PM
d: giorno del mese in due cifre, da "0" a "31";
D: giorno del mese in formato testo, ad esempio "Mon";
F: mese, in formato testuale, ad esempio "March";
h: ora nel formato "01", "12";
H: ora nel formato "00", "23";
g: ora nel formato "1", "12";
G: ora nel formato "0", "23";
i: minuti, nel formato "00", "59";
j: giorno del mese nel formato "1", "31";
l: giorno della settimana, ad esempio "Monday";
L: specifica se l'anno è bisestile o meno ("1" oppure "0");
m: mese nel formato "01", "12";
n: mese nel formato "1", "12";
M: mese in formato testuale corto, ad esempio "Jan";
s: secondi da "00" a "59";
S: suffisso inglese per gli ordinali, "st", "nd", "rd", "th";
t: numero di giorni nel mese corrente, da "28" a "31";
w: giorno della settimana in formato numerico ("0"=domenica);
Y: anno in quattro cifre, ad esempio "2000";
y: anno in due cifre, ad esempio "00";

decibin: converte un numero da decimale a binario; ad esempio, il numero "10" decimale è "1010" in formato binario, e con del semplice codice PHP potremo scrivere:

dechex: converte un numero da decimale a esadecimale; la sintassi è identica a quella utilizzata per decbin();

decoct: converte un numero da formato decimale a formato ottale; la sintassi è la stessa utilizzata per decbin();

define: definisce una costante; come abbiamo visto nel capitolo sulle costanti, queste sono simili alle variabili solamente che non hanno il simbolo del dollaro davanti; per definire una costante si utilizza la seguente sintassi:

defined: controlla che una certa costante esista: un esempio potrebbe essere:

define("COSTANTE", "Questa è una costante");
if (defined("COSTANTE")) {
echo "La costante è definita\n";
} else {
echo "La costante non è definita\n";
}

if (defined($num)) {
echo "\$num è definito\n";
} else {
die ("\$num non è definito; impossibile proseguire\n");
}

dirname: quando si specifica un path, riporta il path senza il nome del file finale: se ad esempio il path è "/home/yourname/public_html/index.php" la funzione restituirà solamente "/home/yourname/public_html":

Avrete notato che questa funzione fa l'esatto contrario della funzione basename(); combinando le due funzioni, si può avere il path completo di un file, compreso il suo nome;

diskfreespace: restituisce lo spazio di disco libero; se volessimo ad esempio vedere quanto spazio rimane nella directory root della macchina, potremo scrivere:

each: restituisce il primo valore di un array utilizzando le keys 0, 1, key e value; se l'array è associativo, si può scrivere:

$array = array ("nome" => "valore", "nome2" => "valore2");
while (list($key, $val) = each ($array)) {
echo "$key => $val\n";
}

$array = array ("nome", "valore", "nome2", "valore2");
while (list($key, $val) = each ($array)) {
echo "$key => $val\n";
}

Come avrete certamente notato, la funzione each() viene spesso utilizzata insieme a list(), che vedremo in seguito;

echo: visualizza una o più stringhe; non penso ci sia molto da dire su questa funzione, vista sia la sua semplicità sia le numerose implicazioni in cui l'abbiamo vista in uso.

ereg_replace: sostituisce un'espressione regolare con determinati valori; alla funzione devono essere passati tre argomenti: il primo indica il testo da sostituire, il secondo è il testo utilizzato per la sostituzione ed il terzo è la stringa da modificare; ad esempio:

$stringa = "Questo è un corso su ASP";
echo ereg_replace("ASP", "PHP", $stringa);

ereg: esegue il matching di un'espressione regolare. L'esempio fornito con la documentazione è alquanto eloquente:

if (ereg("([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})", $date, $regs)) {
echo "$regs[3].$regs[2].$regs[1]";
} else {
echo "Invalid date format: $date";
}

Tutto questo ciclo è fatto per controllare che una data sia in formato corretto. Vediamo il significato di "[0-9]{4})-([0-9]{1,2})-([0-9]{1,2}". Per chi conosca le espressioni regolari, non sarà difficile tradurre quanto sopra con "un numero da 0 a 9 ripetuto quattro volte seguito da un '-', da un numero da 0 a 9 ripetuto una o due volte, da un '-' e da un numero da 0 a 9 ripetuto una o due volte". Come spesso accade, leggere un'espressione regolare è molto più semplice che tradurla nel linguaggio parlato.

eregi_replace: funziona esattamente come ereg_replace(), solamente che in questo caso l'espressione regolare è sostituita in maniera "case insensitive", ossia ignorando i caratteri maiuscoli e minuscoli;

eregi: funziona esattamente come ereg(), solamente che in questo caso l'espressione regolare è sostituita in maniera "case insensitive";

error_log: invia un messaggio di errore al file di log del Web Server, direttamente alla porta TCP dalla quale è arrivata la richiesta o in un file. La sintassi è:

Message_type è un numero che specifica dove deve arrivare il messaggio. Può essere:

0: il messaggio è inviato al logger del PHP o nel file specificato da "error_log";
1: il messaggio è inviato per email al parametro (probabilmente un valido indirizzo email) specificato in "destination"; 2: il messaggio è inviato al debugger;
3: il messaggio è inserito in append al parametro specificato in destination";

exit: esce da uno script; il comando exit() è utile nei casi si voglia fermare uno script in caso qualcosa non soddisfi determinate condizioni, ad esempio:

Ricordate che exit() non riporta un messaggio di errore come fa die(): se vi interessa dare "spiegazioni" sul perchè lo script termina, utilizzate die(), ma ricordate che non è possibile scrivere:

exp: eleva "e" (2.71828.....) alla potenza riportata come argomento della funzione:

explode: divide una stringa secondo un determinato pattern. Ad esempio, volendo dividere una stringa contenente tre nomi separati da virgole possiamo scrivere:

$nomi = "Tizio,Caio,Sempronio";
list ($nome1, $nome2, $nome3) = explode (",", $nomi);
echo "$nome1\n$nome2\n$nome3\n";

Explode() è una versione semplificata di split(), che vedremo in seguito. Entrambe le funzioni, inoltre, sono molto utili nel caso ci sia la necessità di leggere determinati file contenenti delle liste;

fclose: chiude un puntatore ad un file precedentemente aperto con fopen(). Si veda fopen() per maggiori informazioni;

feof: testa un puntatore ad un file per vedere se si è alla fine dello stesso;

fgetc: restituisce il primo carattere del puntatore precedentemente aperto con fopen(); se ad esempio il puntatore $file punta al file "/tmp/prova.txt" che contiene solamente la riga "Ciao", un codice come il seguente:

file_exists: controlla se un file esiste, riportando TRUE in caso positivo o FALSE in caso negativo; ad esempio:

Può essere molto utile utilizzare questa funzione nel caso sia necessario agire su uno o più file, in modo da agire sullo stesso solo nel caso questo esista senza rischiare di incorrere in inspiegabili "anomalie" dello script;

$filename = "/tmp/prova.txt";
$group = filegroup($filename);
echo "$filename appartinene al gruppo $group\n";

$filename = "/tmp/ptova.txt";
$size = filesize($filename);
echo "$filename -> $size\n";

filetype: determina il tipo di file; i valori possibili sono: fifo, char, dir, block, link, file e unknown;

flock: applica il locking ad un file; specificamente, flock() opera su un puntatore ad un file precedentemente aperto e le operazioni possibili sono:

1: per il lock in lettura;
2: per il lock in scrittura;
3: per rimuovere il lock, di qualsiasi tipo sia;
4: per impedire che flock() blocchi un file mentre applica il lock;

Ad esempio, per applicare flock() ad un puntatore "$file" precedenemente definito occorrerà scrivere:

/* Per impedire che il file sia letto*/
flock($file, 2);
/* Codice per lavorare sul file */
.....
/* Per rimuovere il flock */
flock($file, 3);

Ovviamente a "filename" corrisponde il nome del file o l'URL dello stesso, ed a "mode" la modalità con il quale questo deve essere aperto: si ha qui la possibilità di scegliere fra:

r: apre il file in sola lettura;
r+: apre il file in lettura ed in scrittura;
w: apre il file in sola scrittura;
w+: apre il file in lettura e scrittura;
a: apre il file in sola scrittura e inserisce il puntatore alla fine del file ("w" lo inserisce alla fine)
a+: apre il file in lettura e scrittura inserendo il puntatore alla fine del file;

Ad esempio, per aprire un file locale in sola lettura scriveremo:

Per tutte le successive operazioni sul file, poi, dovremo agire direttamente sul puntatore ($file) e non direttamente sul file;

implode: come risulta dal nome, questa funzione non è che l'opposto di explode: la sintassi è identica, ma in questo caso restituisce una stringa con i valori separati dal primo argomento della funzione;

in_array: restituisce valore vero se in un array è presente un determinato valore; un esempio potrebbe essere:

$numeri = array("1", "2", "3", "4", "5");
$num = 2;
if (in_array($num, $numeri)) {
print "$num è presente nell'array \$numeri\n";
}

La stessa cosa viene fatta, con ovviamente la differenza dell'argomento, dalle funzioni:

- is_dir;
- is_double;
- is_executable;
- is_file;
- is_float;
- is_int;
- is_integer;
- is_link;
- is_long;
- is_object;
- is_readable;
- is_real;
- is_string;
- is_writeable.

isset: restituisce TRUE nel caso la variabile esista, falso nel caso opposto; ad esempio, per vedere se esiste o meno una variabile, è possibile scrivere:

che restituirà 1 e 0; ricordiamo che 1 è considerato valore di successo (TRUE), 0 di insuccesso (FALSE);

join: unisce gli elementi di un array con una determinata stringa; l'uso è identico a quello di implode();

$array = array ("nome1" => "valore1", "nome2" => "valore2");
echo join($array);

che restituirà

key: prende una chiave da un array associativo; un semplice esempio potrebbe essere:

che restituirà "1". Questa funzione è utile per estrarre tutte le chiavi di array associativi complessi;

Le informazioni sui link (a proposito dell'esistenza del file a cui punta il link stesso) possono essere visualizzate con


linkinfo()

;

list: assegna delle variabili come se fossero parti di un array; riprendiamo l'esempio fatto con each:

$array = array ("nome" => "valore", "nome2" => "valore2");
while (list($key, $val) = each ($array)) {
echo "$key => $val\n";
}

In questo caso, list() è utilizzato per "stilare" una lista di variabili che verranno estratte dall'array, senza ovviamente dare loro un valore ma lasciando alle parti successive del codice l'assegnazione dei loro valori. È inoltre utile notare che le variabili create da list() non assumono un solo valore, ma per ogni chiamata assumono un diverso valore, a seconda degli elementi presenti nell'array.

Supponendo di voler inviare un'email a "nome@host.com" con subject "Prova" e volendo specificare il nome del mittente, possiamo scrivere:

mail("nome@host.com", "Subject", "Questo è il corpo dell'email","From: mittente <mittente@host.net>);

Come vedete, inviare delle email tramite script PHP ed utilizzando la funzione "mail" è molto semplice. Ovviamente, nel file di configurazione, dovrete aver specificato la locazione di sendmail (o analogo programma per l'invio delle email);

$num = 1;
$num2 = 23;
$num3 = 0.3;
$max = max($num, $num2, $num3);
echo $max, "\n";

restituirà "23". Opposto a max() è min(), che adotta la stessa sintassi di max();

mkdir: crea una directory, di cui si deve specificare il percorso ed i permessi:

opendir: apre una directory, della quale sarà possibile leggere gli elementi con readdir() e, successivamente, chiuderla con closedir();

phpinfo: è la funzione più "rappresentativa" del PHP, in quanto visualizza moltissime informazioni sul PHP stesso: l'uso dovrebbe essere noto:

popen: apre un puntatore ad un processo che deve essere chiuso con pclose();

rand: genera un valore numerico in maniera casuale; se si volesse un valore compreso fra 10 e 20, si potrebbe scrivere:

range: crea un array contenente un range di valori interi specificato; ad esempio, per creare un array con valori da 1 a 10 sarà necessario scrivere:

rmdir: come l'analogo sommando unix, rimuove una directory; questo può essere fatto solo se:

$numero = round(2,3); /* restituisce 2 */
$numero = round(2.5); /* restituisce 3 */
$numero = round(2.6); /* restituisce 3 */

Come avrete notato, i decimali da 0 a 4 sono approssimati all'intero precedente, da 5 a 9 all'intero successivo

shuffle: ordina in modo casuale gli elementi di un array; ad esempio, per poter visualizzare gli elementi di un array in maniera casuale si potrebbe scrivere:

$num = range(0,10);
shuffle($num);
while (list(,$numero) = each($num)) {
echo "$numero ";
}

sizeof: calcola il numero di elementi presenti in un array. Se ad esempio si volesse calcolare il numero di elementi in un array ed agire di conseguenza, si potrebbe scrivere:

$array = array("1", "2", "3", "4", "5");
$size = sizeof($array);
if ($size <= 10) {
echo "L'array contiene meno di 10 elementi\n";
} else {
echo "L'array contiene più di 10 elementi\n";
}

sleep: mette lo script in pausa per un determinato numero di secondi, specificato come argomento della funzione; ad esempio, sleep(10) farà in modo che lo script venga sospeso per 10 secondi, per poi continuare normalmente;

$linea = "tizio||caio||sempronio";
list ($uno, $due, $tre) = split("\|\|", $linea, 3);
print "1 => $uno\n2 => $due\n3 => $tre\n";

Notate che è stato necessario inserire un carattere di escape (\) prima di ogni "|" nell'espressione da utilizzare per dividere la riga;

$cmp = strcmp("Ciao", "Ciao a tutti");
if ($cmp == "0") {
   print "Le stringhe sono identiche\n";
} elseif ($cmp < 0) {
   print "La seconda riga è più lunga della prima\n";
} elseif ($cmp < 0) {
   print "La prima riga è più lunga della prima\n";
}

restituisce "La seconda riga è più lunga della prima". La funzione, infatti, restituisce "0" se le stringhe sono uguali, un valore minore di zero se la seconda è più lunga della prima e maggiore di zero se la prima è più lunga della seconda;

system: esegue un programma di sistema, ne restituisce l'output e ritorna allo script;

usleep: come sleep(), ma questa funziona blocca lo script per N microsecondi.

Con questo, abbiamo terminato di vedere quali sono le funzioni più utili del PHP, senza addentrarci in argomenti come database e simili. Ovviamente, la lista delle funzioni non termina qui ma, essendocene altrettante meno utili almeno per chi inizia a programmare con questo linguaggio, abbiamo preferito fermarci a questo punto. Altre specifiche le tratteremo nelle lezioni successive.

Nel precedente paragrafo "funzioni" abbiamo visto le principali funzioni legate al linguaggio per la creazione delle nostre pagine dinamiche. La differenza fra quelle funzioni e la famiglia di quelle che andremo a vedere è sostanziale: le prime sono presenti direttamente all'interno del motore (built-in), le seconde sono presenti in librerie aggiuntive che devono essere installate sul sistema e richiamate in maniera particolare.

Prima di tutto, vediamo di capire il meccanismo di caricamento dinamico di queste librerie: aprendo il file php.ini vedremo un paragrafo dedicato alle "Extension", ossia estensioni nel linguaggio stesso: per spiegarci meglio, potremo dire che queste sono un insieme di librerie che vengono richiamate al momento dell'esecuzione di uno script come avviene, in maniera analoga, per il caricamento dei moduli con un webserver. La sintassi per il caricamento di queste estensioni di linguaggio è molto semplice: una volta che avremo installato la libreria sul sistema, non ci resta che aggiungere nel file php.ini la riga:

È qui necessario un discorso mirato per i sistemi Unix ed i sistemi Windows: per entrambi la sintassi è identica, ma ovviamente il nome delle librerie e la loro estensione no. Nei sistemi Windows, una libreria si riconosce dall'estensione ".dll", mentre per Unix questa è ".so": quindi, a seconda del sistema, dovremo utilizzare il corretto nome per la libreria e, soprattutto, la corretta estensione. Ovviamente, per chi abbia entrambi i sistemi installati e riesca da uno dei sistemi a vedere l'altro è chiaro che le dll non possono essere caricate su un sistema Unix e viceversa.

Nello scrivere il nome della libreria che ci interessa caricare, non dobbiamo soffermarci sul percorso completo, ma è necessario solamente il nome della stessa, ad esempio pgsql.so per i database Postgres. Questo perchè, nello stesso file, è presente un'altra linea di configurazione che definisce in quale directory sono presenti queste librerie: leggendo il file php.ini potrete trovare la riga extension_dir = directory che istruirà il motore sulla locazione standard delle librerie. Quindi, quando specifichiamo con extension una libreria che vogliamo sia caricata per l'esecuzione di uno script, vengono di fatto uniti extension_dir ed extension: se ad esempio extension_dir è /usr/lib/php e abbiamo impostato extension=pgsql.so, il PHP saprà che per caricare la libreria pgsql.so dovrà cercarla in /usr/lib/php/pgsql.so.

Inoltre, con l'istruzione extension= .... è possibile specificare non solo una libreria ma tutta la seri di librerie che ci possono fare comodo: ad esempio possiamo avere qualcosa del tipo:

extension=pgsql.so
extension=mysql.so
extension=gd.so
extension=imap.so
extension=ldap.do
extension=xml.so

e via dicendo; come noterete dalla seconda riga, poi, è possibile specificare anche due o più librerie per uno stesso "campo" in questo caso, ci sono due librerie per due database (Postgres e MySQL) che, oltre a non entrare in conflitto l'una con l'altra, potrebbero teoricamente anche essere utilizzate contemporaneamente, a patto che questo abbia un'utilità.

Nel caso si cerchi di richiamare una funzione non built-in all'interno di uno script, lo script visualizza una messaggio d'errore che ci avverte che stiamo cercando di utilizzare una funzione non riconosciuta: ad esempio, per i database, devono essere caricate le estensioni come detto prima e, solo dopo aver compiuto questo passo, sarà possibile utilizzare le funzioni ad essi relativi senza incorrere in messaggi d'errore, sempre che queste siano utilizzate in maniera corretta, ovviamente.

A questo punto, ci sarà sicuramente chi si chiederà il perchè di questa librerie aggiuntive (a volte molto importanti o addirittura essenziali) che devono essere scaricate, installate e richiamate indirettamente. La spiegazione è semplice: per non appesantire inutilmente il motore. Di per sè questo ha già un grande numero di funzioni built-in, che potremo definire le funzioni "principali" per il linguaggio, sebbene alcune possano sembrare di poca utilità. Immaginate ora che il motore avesse al suo interno anche tutte le funzioni relative a tutti i database che supporta: avrebbe un altro centinaio (abbondante) di funzioni al suo interno; e questo non sarebbe un male se il 95% di queste non fosse inutilizzato.

Chi, infatti, ha la necessità di lavorare con il PHP ed una decina di database differenti? È sicuramente meglio installare l'estensione per il database che si deve utilizzare e non appesantire il motore con funzioni che certamente non utilizzeremo mai. Inoltre, pensate anche alle funzioni della libreria GD: senza dubbio sono interessanti per i risultati che permettono di ottenere, ma quanti in realtà le utilizzano? È più semplice fornire tutte queste funzioni in un file separato e lasciare che questo venga installato ed utilizzato da chi ne ha veramente bisogno.

Se ci pensate, è quello che avviene per tutti i linguaggi di programmazione: esistono le primitive (che, in linea di massima, possiamo definire come le funzioni essenziali e built-in in un sistema) e le funzioni in qualche modo esterne che vengono richiamate all'occorrenza. Rimanendo nei linguaggi di scripting, un paragone può essere fatto ad esempio con il Perl: anch'esso ha una nutrita schiera di funzioni built-in nell'interprete, alle quali si aggiungono la quasi infinità di moduli che il programmatore può utilizzare all'interno delle proprie creazioni.

Con l'avvento di PHP 5 il modo di concepire la programmazione ad oggetti in PHP è cambiato radicalmente. Il modello ad oggetti semplificato che era presente fino alla versione 4 non è che un'ombra scialba di quello attuale. Prima gli oggetti erano solamente una funzionalità di supporto poco utilizzata e veramente troppo poco flessibile. Ora gli sviluppatori possono puntare su un supporto alla programmazione ad oggetti che avvicina il linguaggio ai concorrenti più blasonati.

In PHP 5 la definizione di una classe rispecchia molto più da vicino le esigenze degli sviluppatori entrerprise. Vediamo di analizzare la sintassi utilizzata con dei brevi esempi.

Php offre agli sviluppatori una serie di funzioni relative alla crittatura, legate alla libreria mcrypt; (http://mcrypt.sourceforge.net/) tale libreria supporta moltissimi algoritmi di crittazione, alcuni più utilizzati ed altri meno. Gli algoritmi sono:

Per funzionare con tale libreria, il PHP deve essere stato compilato con l'opzione --with-mcrypt. I comandi fondamentali sono quattro, tutti con la medesima sintassi:

$encrypted = mcrypt_XXX(algoritmo, chiave, input, encode/decode)

MCRYPT_BLOWFISH oppure MCRYPT IDEA

MCRYPT_ENCRYPT e MCRYPT_DECRYPT

Vediamo ora un esempio: volendo crittare una semplice stringa di testo con chiave di crittatura "La mia chiave" utilizzando CFB con l'algoritmo IDEA, dovremo scrivere:

$stringa = "Una semplice stringa di testo";
$chiave = "La mia chiave";
$encrypted = mcrypt_cfb(MCRYPT_IDEA, $chiave, $stringa, MCRYPT_ENCRYPT);

Chiunque voglia poi leggere i nostri dati crittati ($encrypted) dovrà ovviamente conoscere la chiave, il metodo e l'algoritmo utilizzati; quindi potrebbe scrivere qualcosa del tipo:

$chiave = "La mia chiave";
$stringa = mcrypt_cfb(MCRYPT_IDEA, $chiave, $encrypted, MCRYPT_DECRYPT);

Fra i vari protocolli, PHP ci mette a disposizione una vasta libreria di funzioni legate al protocollo FTP (FILE TRANSFER PROTOCOL), per il trasferimento di file da un computer all'altro in una rete. Vediamone le principali.

ftp_connect

Questa è la funzione "principale" nel senso che ci permette di stabilire una connessione FTP fra la nostra macchina ed il server FTP remoto. La sua sintassi è:

$stream = ftp_connect(host, port);

dove host è il nome del server a cui intendiamo connetterci e port (opzionale) è la porta alternativa alla quale ci si vuole connettere; se questa non è specificata, viene utilizzata la porta di default per il protocollo FTP, ossia la 21. Nella variabile $stream, inoltre, viene immagazzinato appunto lo stream di dati che il client (in questo caso il PHP) riceve dal server, ossia i messaggi di connessione accettata (con i vari dettagli) o di connessione rifiutata.

Ad esempio, per connetterci alla porta di default del server FTP "ftp://ftp.host.com" utilizzeremo:

$stream = ftp_connect("ftp://ftp.host.com");

ftp_login

Dopo la connessione, abbiamo bisogno di identificarci in modo che il server ci permetta lo scambio dei dati. molti saranno abituati a non vedere tale fase visto che, con i più diffusi client FTP grafici essa è svolta in automatico utilizzando le informazioni di login (username e password) inseriti come opzioni per il collegamento, ma sappiate che questa è una fase di vitale importanza per la connessione. La sintassi della funzione è:

$login = ftp_login(stream, username, password);

Se ad esempio in precedenza ci eravamo collegati all'host "ftp.host.com", utilizzando la variabile "$stream", adesso potremo procedere al login vero e proprio con:

$login = ftp_login($stream, "utente", "password");

La variabile $login ci servirà per capire se il login è andato o meno a buon fine e conterrà il valore "1" per il successo, "0" altrimenti. Ad esempio, per vedere se continuare lo scambio di dati in seguito all'autorizzazione potremo utilizzare il valore assegnato a tale variabile e scrivere:

if ($login == "1") {
... # Fai il resto delle operazioni
} else {
echo "Autorizzazione non riuscita\n";
}

Una volta connessi, potremo sapere su che macchina stiamo lavorando con la funzione ftp_systype() che ha sintassi:

$system = ftp_systype($stream);

ftp_pwd

Questa funzione invoca il comando "pwd", ovvero "Print work directory", che potremo tradurre come "Visualizza la directory corrente". Per vedere a che directory veniamo connessi dopo il login, potremo scrivere:

$directory = ftp_pwd($stream);

dove $stream è sempre la variabile che abbiamo utilizzato per la connessione con ftp_connect().

ftp_cdup e ftp_chdir

Queste due funzioni servono rispettivamente a muoversi alla directory superiore e a muoversi in una determinata directory all'interno del server.
La prima si utilizza con sintassi:

$var = ftp_cdup($stream);

$newdir = ftp_chdir($stream, "nuova_directory");

Se ad esempio al login siamo nella directory "/" e volessimo spostarci in "/var/wwwdata" potremo scrivere:

$newdir = ftp_chdir($stream, "/var/wwwdata");

ftp_mkdir e ftp_rmdir

Queste due funzioni invocano il comando "mkdir "(crea una directory) e "rmdir" (rimuovi una directory). La prima restituisce il nome della nuova directory, la seconda solamente i valori true o false. Potremo creare un piccolo loop e scrivere:

# Posizioniamoci in "/var/wwwdata".
$mydir = ftp_chdir($stream, "/var/wwwdata/");

# Creiamo la directory "prova" come sottodirectory di "/var/wwwdata"
$newdir = ftp_mkdir($stream, "prova")

# Cancelliamo la directory appena creata!
$deleted_dir = ftp_rmdir($stream, $newdir);

# Possiamo ora controllare il tutto con:
if ($deleted_dir == "1") {
print "Operazione completata con successo.\n";
} else {
print "Qualcosa non è andato per il verso giusto.\n";
}

Ovviamente l'esempio non ha molto senso in una vera connessione (perchè creare una directory e subito cancellarla?), ma è stato proposto per comprendere come utilizzare al meglio queste due funzioni.

ftp_nlist

Questa funzione è analoga al comando "dir", ossia il comando utilizzato per vedere i nomi dei file presenti in una directory. La sua sintassi è:

$list = ftp_nlist($stream, directory);

Ad esempio, possiamo portarci nella directory "/var/wwwdata" e leggerne i file con:

$newdir = "/var/wwwdata";
$list = ftp_nlist($stream, $newdir);

I risultati sono contenuti in un array, quindi un 'echo "$list"' non avrebbe alcun senso.

ftp_get

Funzione che richiama il comando GET, per scaricare un file dal server remoto. Dobbiamo specificare per la funzione, oltre al solito stream, il nome del file locale, il nome del file remoto e la modalità di trasferimento (FTP_ASCII o FTP_BINARY); la sintassi completa è:

$file = ftp_get($stream, local_filename, remote_filename, mode);

Ad esempio, volendo scaricare dal server il file "data.txt" (supponiamo di essere già all'interno della directory che lo contiene) inserendolo nella directory "/tmp" con nome "file.txt" in ASCII mode, scriveremo:

$file = ftp_get($stream, "/tmp/file.txt", "data.txt", FTP_ASCII);

Per vedere se l'operazione ha avuto o meno successo, possiamo operare in due modi: controllare se effettivamente il file c'è nel nostro disco oppure controllare il valore della variabile $file: se ha valore "1" allora l'operazione è stata completata, se ha valore "0" nessun file sarà stato scaricato sul nostro disco.

ftp_put

Questa funzione fa esattamente il contrario di ftp_put(), ossia carica un file sul server. La sua sintassi è:

$file = ftp_put($stream, remote_filename, local_filename, mode);

Le opzioni sono identiche alle precedenti, quindi possiamo fare l'esempio contrario del precedente: carichiamo il file locale "/tmp/file.txt" nella directory remota (siamo già in questa directory) con il nome "data.txt". Tutto in ASCII mode, ovviamente:

$file = ftp_put ($stream, "data.txt", "/tmp/file.txt", FTP_ASCII);

Anche qui, possiamo controllare in due modi: valutando il valore di $file oppure invocando la funzione ftp_nlist() per vedere se fra i file c'è anche "data.txt".

ftp_size

$size = ftp_size($stream, remote_filename);

Per tornare agli esempi precedentemente fatti, vediamo di conoscere la grandezza del file "data.txt", che si trova nella directory in cui siamo al momento; basterà scrivere:

$size = ftp_size($stream, "data.txt");

ftp_mdtm

Restituisce la data di ultima modifica di un file, restituendola come Unix timestamp. La sintassi è:

$date = ftp_mdtm($stream, remote_filename);

Ad esempio, volendo sapere la data di ultima modifica del file "data.txt" possiamo scrivere:

$date = ftp_mdtm($stream, "data.txt");

Anche in questo caso, la variabile "$data" conterrà la data di ultima modifica del file oppure il valore "-1" in caso di insuccesso (file inesistente o casi del genere).

ftp_rename e ftp_delete

Come apparirà chiaro dai nomi, queste due funzioni servono per rinominare un file e per cancellarlo. La prima ha sintassi:

$name = ftp_rename($stream, oldname, newname);

dove "oldname" è il nome originario del file e "newname" è il nuovo nome che vogliamo assegnare al file.
Ad esempio, per rinominare il file "data.txt" in "dati.dat" possiamo scrivere:

$name = ftp_rename($stream, "data.txt", "dati.dat");

La variabile $name conterrà "1" se l'operazione ha avuto successo, "0" altrimenti (file inesistente o casi simili).

La funzione ftp_delete(), invece, si utilizza con sintassi:

$delete = ftp_delete($stream, file);

Ad esempio, per eliminare il file "dati.dat" presente nella "current-directory" possiamo scrivere:

$delete = ftp_delete ($stream, "dati.dat");

Anche in questo caso la variabile può contenere valore "1" (il file è stato eliminato) o "0" (qualcosa non è andato per il verso giusto).

ftp_quit

A questo punto, il nostro lavoro sul server è terminato e possiamo disconnetterci utilizzando la funzione ftp_quit() che ha la semplice sintassi:

$quit = ftp_quit($stream).

È sempre consigliato invocare questa funzione invece di chiudere il programma in esecuzione, più che altro per una questione di rispetto verso il server.

(tratto dal sito:http://php.html.it/guide/leggi/97/guida-php-teorica/ - di Edoardo Valsesia) - WWW.HTML.IT