Php-5

11.Le Funzioni in Php

			
11_1.FUNZIONI: Gestire le Variabili			
La funzione ha lo scopo di eseguire determinate istruzioni nel momento stesso in cui viene chiamata.
Ci basta infatti richiamare la funzione, (fornendole i dovuti parametri se richiesti), per la sua esecuzione.

La sintassi fondamentale con la quale si richiama una funzione è molto semplice:

nome_funzione();

Si tratta semplicemente di indicare il nome della funzione, seguito da parentesi tonde. Queste parentesi devono contenere i parametri da passare alla funzione, ma vanno obbligatoriamente indicate anche se non ci sono parametri, nel qual caso rimangono vuote come nell'esempio che abbiamo visto sopra. Nel caso poi in cui la funzione restituisca un valore, possiamo indicare la variabile in cui immagazzinarlo:

$valore = nome_funzione();

In questo modo, la variabile $valore riceverà il risultato della funzione. Le funzioni possono essere utilizzate anche all'interno di espressioni: in tal caso il valore restituito verrà utilizzato durante la valutazione dell'espressione:

$prova = (10 * numero_anni()) - numero_casuale();

Le funzioni possono essere incorporate nel linguaggio oppure definite dall'utente.

Cominciamo dalle principali funzioni che operano sulle variabili in generale:

    empty(valore):
verifica se la variabile che le passiamo è vuota oppure no. Per 'vuota' si intende che la variabile può contenere una stringa vuota o un valore numerico pari a 0, ma può anche essere non definita o essere impostata al valore NULL (l'eventuale indicazione di una variabile non definita, in questo caso, non genera errore notice). Restituisce un valore booleano (vero o falso).

    isset(valore):
verifica se la variabile è definita. Una variabile risulta non definita quando non è stata inizializzata o è stata impostata col valore NULL. Restituisce un valore booleano.

    is_null(valore):
verifica se la variabile equivale a NULL, ma genera un errore 'notice' se viene eseguito su una variabile non definita. Restituisce un valore booleano.

    is_int(valore), is_integer(valore), is_long(valore):
verifica se la variabile è di tipo intero. Le tre funzioni sono equivalenti. Restituiscono un valore booleano.

    is_float(valore), is_double(valore), is_real(valore):
verifica se la variabile è di tipo numerico double (o float). Le tre funzioni sono equivalenti. Restituiscono un valore booleano.

    is_string(valore):
verifica se la variabile è una stringa. Restituisce un valore booleano.

    is_array(valore):
verifica se la variabile è un array. Restituisce un valore booleano.

    is_numeric(valore):
verifica se la variabile contiene un valore numerico. È molto importante la distinzione fra questa funzione e is_int() o is_float(), perchè queste ultime, nel caso di una stringa che contiene valori numerici, restituiscono falso, mentre is_numeric() restituisce vero. Restituisce un valore booleano.

    gettype(valore):
verifica quale tipo di dato le abbiamo passato. Restituisce una stringa che rappresenta il tipo di dato, ad esempio: 'boolean', 'integer', 'double', 'string', 'array'. È bene però, in uno script, non fare affidamento su questi valori per dedurre il tipo di dato, perchè in versioni future di PHP alcune di queste stringhe potrebbero essere modificate. Meglio usare le funzioni viste prima.

    print_r(valore):
stampa (direttamente sul browser) informazioni relative al contenuto della variabile che le abbiamo passato. È utile in fase di debug, quando a seguito di comportamenti 'strani' del nostro script vogliamo verificare il contenuto di certi dati. Se il valore passato è un array, la funzione ne evidenzia le chiavi ed i valori relativi. Restituisce un valore booleano.

    unset(valore):
distrugge la variabile specificata. In realtà non si tratta di una funzione, ma di un costrutto del linguaggio, e ne abbiamo già parlato nella lez. 8. Dopo l'unset(), l'esecuzione di empty() o is_null() sulla stessa variabile restituirà vero, mentre isset() restituirà falso. Non restituisce valori.

Vediamo ora qualche esempio per chiarire l'utilizzo di queste funzioni:

$b = empty($a); //$a non è ancora definita, quindi $b sarà vero
$a = 5;
$b = isset($a); //vero
$b = is_float($a); //falso: $a è un intero
$b = is_string($a); //falso


$a = '5';
$b = is_int($a); //falso: $a ora è una stringa
$b = is_string($a); //vero
$b = is_numeric($a); //vero: la stringa ha un contenuto numerico
$c = gettype($b); //$c prende il valore 'boolean'


unset($a); //eliminiamo la variabile $a;
$b = is_null($a); //vero, ma genera errore

In questi esempi abbiamo sempre assegnato alla variabile $b i valori booleani restituiti dalle funzioni. Nella pratica, è più frequente che tali valori non siano memorizzati in variabili, ma che vengano usati direttamente come condizioni, ad esempio per delle istruzioni di tipo if. Ancora un paio di esempi:

if (empty($a)) {
  print ('$a è vuota o non definita!');
}
else {
  print ('$a contiene un valore');
}


if (is_numeric($a)) {
  print ('$a contiene un valore numerico');
}
else {
  print ('$a non contiene un numero');
}



11_2.FUNZIONI: Gestire le Stringhe 
Passiamo ora ad esaminare alcune funzioni che operano sulle stringhe (l'eventuale indicazione di un parametro tra parentesi quadre indica che quel parametro è facoltativo, quindi può non essere indicato nel momento in cui si chiama la funzione):

    strlen(stringa):
verifica la lunghezza della stringa, cioè il numero di caratteri che la compongono. Restituisce un numero intero.

    trim(stringa):
elimina gli spazi all'inizio e alla fine della stringa. Restituisce la stringa modificata.

    ltrim(stringa):
elimina gli spazi all'inizio della stringa. Restituisce la stringa modificata.

    rtrim(stringa):
elimina gli spazi alla fine della stringa. Restituisce la stringa modificata.

    substr(stringa, intero [, intero]):
restituisce una porzione della stringa, in base al secondo parametro (che indica l'inizio della porzione da estrarre), e all'eventuale terzo parametro, che indica quanti caratteri devono essere estratti. Se il terzo parametro non viene indicato, viene restituita tutta la parte finale della stringa a partire dal carattere indicato. Da notare che i caratteri vanno contati a partire da zero, per cui se si chiama la funzione con substr(stringa, 4) verranno restituiti tutti i caratteri a partire dal quinto. Si può anche indicare un numero negativo come carattere iniziale: in questo caso, il carattere iniziale della porzione di stringa restituita verrà contato a partire dal fondo. Ad esempio, con substr(stringa, -5, 3) si otterranno tre caratteri a partire dal quintultimo (da notare che in questo caso il conteggio non inizia da zero, ma da 1: cioè -1 indica l'ultimo carattere, -2 il penultimo e così via). Se infine si indica un numero negativo come terzo parametro, tale parametro non verrà più utilizzato come numero di caratteri restituiti, ma come numero di caratteri non restituiti a partire dal fondo. Esempio: substr(stringa, 3, -2) restituisce i caratteri dal quarto al terzultimo. La funzione restituisce la porzione di stringa richiesta.

    str_replace(stringa, stringa, stringa):
effettua una sostituzione della prima stringa con la seconda all'interno della terza. Ad esempio: str_replace('p', 't', 'pippo') sostituisce le 'p' con le 't' all'interno di 'pippo', e quindi restituisce 'titto'. Restituisce la terza stringa modificata. Esiste anche la funzione str_ireplace(), che è equivalente ma che cerca la prima stringa nella terza senza tener conto della differenza fra maiuscole e minuscole.

    strpos(stringa, stringa):
cerca la posizione della seconda stringa all'interno della prima. Ad esempio: strpos('Lorenzo', 're') restituisce 2, ad indicare la terza posizione. Restituisce un intero che rappresenta la posizione a partire da 0 della stringa cercata. Se la seconda stringa non è presente nella prima, restituisce il valore booleano FALSE. La funzione stripos() fa la stessa ricerca senza tenere conto della differenza fra maiuscole e minuscole.

    strstr(stringa, stringa):
cerca la seconda stringa all'interno della prima, e restituisce la prima stringa a partire dal punto in cui ha trovato la seconda. strstr('Lorenzo', 're') restituisce 'renzo'. Restituisce una stringa se la ricerca va a buon fine, altrimenti il valore booleano FALSE. La funzione stristr() funziona allo stesso modo ma non tiene conto della differenza fra maiuscole e minuscole.

    strtolower(stringa):
converte tutti i caratteri alfabetici nelle corrispondenti lettere minuscole. Restituisce la stringa modificata.

    strtoupper(stringa):
converte tutti i caratteri alfabetici nelle corrispondenti lettere maiuscole. Restituisce la stringa modificata.

    ucfirst(stringa):
trasforma in maiuscolo il primo carattere della stringa. Restituisce la stringa modificata.

    ucwords(stringa):
trasforma in maiuscolo il primo carattere di ogni parola della stringa, intendendo come parola una serie di caratteri che segue uno spazio. Restituisce la stringa modificata.

    explode(stringa, stringa [, intero]):
trasforma la seconda stringa in un array, usando la prima per separare gli elementi. Il terzo parametro può servire ad indicare il numero massimo di elementi che l'array può contenere (se la suddivisione della stringa portasse ad un numero maggiore, la parte finale della stringa sarà interamente contenuta nell'ultimo elemento). Ad esempio: explode(' ', 'ciao Mario') restituisce un array di due elementi in cui il primo è 'ciao' e il secondo 'Mario'. Restituisce un array.

Dobbiamo fare un'annotazione relativa a tutte queste funzioni, in particolare quelle che hanno lo scopo di modificare una stringa: la stringa modificata è il risultato della funzione, che dovremo assegnare ad una variabile apposita. Le variabili originariamente passate alla funzione rimangono invariate. Vediamo alcuni esempi sull'uso di queste funzioni:

$a = 'IERI ERA DOMENICA';
$b = strtolower($a); /* $b diventa 'ieri era domenica', ma $a rimane 'IERI ERA DOMENICA' */


strlen('abcd'); //restituisce 4
trim(' Buongiorno a tutti '); //restituisce 'Buongiorno a tutti'
substr('Buongiorno a tutti', 4); /* 'giorno a tutti' (inizia dal quinto) */
substr('Buongiorno a tutti', 4, 6); /* 'giorno'(6 caratteri a partire dal quinto) */
substr('Buongiorno a tutti', -4); //'utti' (ultimi quattro)
substr('Buongiorno a tutti', -4, 2); /* 'ut' (2 caratteri a partire dal quartultimo) */
substr('Buongiorno a tutti, 4, -2); /* 'giorno a tut' (dal quinto al terzultimo) */


str_replace('Buongiorno', 'Ciao', 'Buongiorno a tutti'); /* 'Ciao a tutti' */
str_replace('dom', 'x', 'Domani è domenica'); //'Domani è xenica'
str_ireplace('dom', 'x', 'Domani è domenica'); //'xani è xenica'
strpos('Domani è domenica', 'm'); //2 (prima 'm' trovata)
strstr('Domani è domenica', 'm'); /* 'mani è domenica' (a partire dalla prima 'm') */
strtoupper('Buongiorno a tutti'); //'BUONGIORNO A TUTTI'
ucfirst('buongiorno a tutti'); //'Buongiorno a tutti';
ucwords('buongiorno a tutti'); //'Buongiorno A Tutti';
explode(',','Alberto,Mario,Giovanni'); /* suddivide la stringa in un array, separando un elemento ogni volta
che trova una virgola; avremo quindi un array di tre elementi: ('Alberto','Mario','Giovanni')*/
explode(',','Alberto,Mario,Giovanni',2); /* in questo caso l'array può contenere al massimo due elementi,
per cui nel primo elemento andrà 'Alberto' e nel secondo il resto della stringa: 'Mario,Giovanni' */



11_3.FUNZIONI: Gestire gli Array
 
Vediamo ora alcune funzioni che operano sugli array:

    count(array): 
conta il numero di elementi dell'array. Restituisce un intero.

    array_reverse(array [, booleano]):
inverte l'ordine degli elementi dell'array. Se vogliamo mantenere le chiavi dell'array di input, dobbiamo passare il secondo parametro con valore TRUE. Restituisce l'array di input con gli elementi invertiti.

    sort(array):
ordina gli elementi dell'array. Bisogna fare attenzione, perchè questa funzione, contrariamente a molte altre, modifica direttamente l'array che le viene passato in input, che quindi andrà perso nella sua composizione originale. I valori vengono disposti in ordine crescente secondo i criteri che abbiamo visto nella lezione 10. Le chiavi vanno perse: dopo il sort, l'array avrà chiavi numeriche a partire da 0 secondo il nuovo ordinamento. Non restituisce nulla.

    rsort(array):
ordina gli elementi dell'array in ordine decrescente. Anche questa funzione modifica direttamente l'array passato in input e riassegna le chiavi numeriche a partire da 0. Non restituisce nulla.

    asort(array):
funziona come sort(), con la differenza che vengono mantenute le chiavi originarie degli elementi. Non restituisce nulla.

    arsort(array):
come rsort(), ordina in modo decrescente; mantiene però le chiavi originarie. Non restituisce nulla.

    in_array(valore, array):
cerca il valore all'interno dell'array. Restituisce un valore booleano: vero o falso a seconda che il valore cercato sia presente o meno nell'array.

    array_key_exists(valore, array):
cerca il valore fra le chiavi (e non fra i valori) dell'array. Restituisce un valore booleano.

    array_search(valore, array):
cerca il valore nell'array e ne indica la chiave. Restituisce la chiave del valore trovato o, se la ricerca non va a buon fine, il valore FALSE.

    array_merge(array, array [, array...]):
fonde gli elementi di due o più array. Gli elementi con chiavi numeriche vengono accodati l'uno all'altro e le chiavi rinumerate. Le chiavi associative invece vengono mantenute, e nel caso vi siano più elementi nei diversi array con le stesse chiavi associative, l'ultimo sovrascrive i precedenti. Restituisce l'array risultante dalla fusione.

    array_pop(array):
estrae l'ultimo elemento dell'array, che viene 'accorciato'. Restituisce l'elemento in fondo all'array e, contemporaneamente, modifica l'array in input togliendogli lo stesso elemento.

    array_push(array, valore [,valore...]):
accoda i valori indicati all'array. Equivale all'uso dell'istruzione di accodamento $array[]=$valore , con il vantaggio che ci permette di accodare più valori tutti in una volta. Restituisce il numero degli elementi dell'array dopo l'accodamento.

    array_shift(array):
estrae un elemento come array_pop(), ma in questo caso si tratta del primo. Anche in questo caso l'array viene 'accorciato', ed inoltre gli indici numerici vengono rinumerati. Rimangono invece invariati quelli associativi. Restituisce l'elemento estratto dall'array.

    array_unshift(array, valore [,valore...]):
inserisce i valori indicati in testa all'array. Restituisce il numero degli elementi dell'array dopo l'inserimento.

    implode(stringa, array):
è la funzione opposta di explode(), e serve a riunire in un'unica stringa i valori dell'array. La stringa indicata come primo parametro viene interposta fra tutti gli elementi dell'array. Restituisce la stringa risultato dell'aggregazione. Suo sinonimo è join().

Ecco qualche esempio sull'uso di queste funzioni:

$arr = array('Luca', 'Giovanni', 'Matteo', 'Paolo', 'Antonio', 'Marco', 'Giuseppe');
$n = count($arr); // $n vale 7
$arr1 = array_reverse($arr); /* $arr1 avrà gli elementi invertiti, da 'Giuseppe' a 'Luca' */
echo $arr[1], '<br>'; // 'Giovanni'
echo $arr1[1], '<br>'; // 'Marco'


sort($arr); /* ora $arr sarà: 'Antonio', 'Giovanni', 'Giuseppe', 'Luca', 'Marco', ' Matteo', 'Paolo' */
$a = in_array('Giovanni', $arr); // $a è vero (TRUE)
$a = in_array('Francesco', $arr); // $a è falso (FALSE)
$ultimo = array_pop($arr); // $ultimo è 'Paolo' (li avevamo ordinati!)
$ultimo = array_pop($arr); /* ora $ultimo è 'Matteo', e in $arr sono rimasti 5 elementi */
$primo = array_shift($arr); // primo è 'Antonio'
$a = array_unshift($arr, $ultimo, $primo); /* 'Matteo' e 'Antonio' vengono reinseriti
in testa all'array; $a riceve il valore 6 */


$stringa = implode(' ', $arr); /* $stringa diventa 'Matteo Antonio Giovanni Giuseppe Luca Marco' */
$new_arr = array_merge($arr, $arr1); /* $new_arr conterrà 13 elementi:
'Matteo', 'Antonio', 'Giovanni', 'Giuseppe', 'Luca', 'Marco' (questi sono i 6 provenienti da $arr),
'Giuseppe', 'Marco',' Antonio', 'Paolo', 'Matteo', 'Giovanni', 'Luca' (questi sono i 7 di $arr1). Gli indici andranno da 0 a 12. */


//Impostiamo ora un array con chiavi associative:
$famiglia = array('padre' => 'Claudio', 'madre' => 'Paola', 'figlio' => 'Marco', 'figlia' => 'Elisa');
$fam1 = $famiglia; /* creiamo una copia del nostro array per poter fare esperimenti */
rsort($fam1); /* ora $fam1 sarà 'Paola', 'Marco', 'Elisa', 'Claudio', con chiavi da 0 a 3 */


$fam1 = $famiglia; //ripristiniamo l'array originale
arsort($fam1); /* di nuovo $fam1 sarà 'Paola', 'Marco', 'Elisa', 'Claudio', ma ciascuno con la sua
chiave originale ('madre', 'figlio', 'figlia', 'padre') */


$a = array_key_exists('figlia', $fam1); // $a è TRUE
$a = array_key_exists('zio', $fam1); //$a è FALSE
$a = array_search('Claudio', $fam1); //$a è 'padre'
$a = array_search('Matteo', $fam1); //$a è FALSE



11_4.FUNZIONI: Gestire le Date

Concludiamo questa panoramica sulle funzioni di PHP con qualche funzione sulla gestione di date e ore. Prima di cominciare, però, dobbiamo fare un accenno al timestamp, sul quale si basano queste funzioni. Il timestamp è un numero intero, in uso da tempo sui sistemi di tipo UNIX, che rappresenta il numero di secondi trascorsi a partire dal 1° gennaio 1970. Ad esempio, il timestamp relativo alle 15.56.20 del 24 aprile 2003 è 1051192580. Vediamo dunque queste funzioni e rimandiamo ad un articolo su HTML.it nel quale questa funzione viene analizzata approfonditamente:

    time():
è la più semplice di tutte, perchè fornisce il timestamp relativo al momento in cui viene eseguita. Restituisce un intero (timestamp).

    date(formato [,timestamp]):
considera il timestamp in input (se non è indicato, prende quello attuale) e fornisce una data formattata secondo le specifiche indicate nel primo parametro.
Tali specifiche si basano su una tabella di cui riassumiamo i valori più usati:

        Y - anno su 4 cifre
        y - anno su 2 cifre
        n - mese numerico (1-12)
        m - mese numerico su 2 cifre (01-12)
        F - mese testuale ('January' - 'December')
        M - mese testuale su 3 lettere ('Jan' - 'Dec')
        d - giorno del mese su due cifre (01-31)
        j - giorno del mese (1-31)
        w - giorno della settimana, numerico (0=dom, 6=sab)
        l - giorno della settimana, testuale ('Sunday' - 'Saturday' )
        D - giorno della settimana su 3 lettere ('Sun' - 'Sat')
        H - ora su due cifre (00-23)
        G - ora (0-23)
        i - minuti su due cifre (00-59)
        s - secondi su due cifre (00-59)

La funzione date() restituisce la stringa formattata che rappresenta la data.

    mktime(ore, minuti, secondi, mese, giorno, anno): è una funzione molto utile ma che va maneggiata con molta cura, perchè i parametri che richiede in input (tutti numeri interi) hanno un ordine abbastanza particolare, che può portare facilmente ad errori. Sulla base di questi parametri, mktime() calcola il timestamp, ma l'aspetto più interessante è che possiamo utilizzarla per fare calcoli sulle date. Infatti, se ad esempio nel parametro mese passiamo 14, PHP lo interpreterà come 12+2, cioè "febbraio dell'anno successivo", e quindi considererà il mese come febbraio ed aumenterà l'anno di 1. Ovviamente lo stesso tipo di calcoli si può fare su tutti gli altri parametri. Restituisce un intero (timestamp).
    checkdate(mese, giorno, anno): verifica se i valori passati costituiscono una data valida. Restituisce un valore booleano.

Vediamo quindi qualche esempio anche per queste funzioni:

$a = mktime(15,56,20,4,24,2003); /* $a riceve il timestamp del 24/4/2003 alle 15.56.20 */
$b = date('d M y - H:i', $a); //$b sarà "24 Apr 03 - 15:56"
$a = mktime(14,0,0,4,24+60,2003); /* timestamp delle ore 14 di 60 giorni dopo il 24/4/2003 */
$c = checkdate(5,1,2003); //vero
$c = checkdate(19,7,2003); //falso (19 non è un mese)
$c = checkdate(4,31,2003); //falso (31 aprile non esiste)



11_5.Scrivere Funzioni Personalizzate

Oltre alle numerosissime funzioni incorporate in PHP abbiamo la possibilità di definire delle nostre funzioni che ci permettono di svolgere determinati compiti in diverse parti del nostro script, o, meglio ancora, in script diversi, semplicemente richiamando la porzione di codice relativa, alla quale avremo attribuito un nome che identifichi la funzione stessa. Vediamo quindi ora come definire una funzione, fermo restando che, al momento di eseguirla, la chiamata si svolge con le stesse modalità con cui vengono chiamate le funzioni incorporate del linguaggio.

Immaginiamo di voler costruire una funzione che, dati tre numeri, ci restituisca il maggiore dei tre.
Vediamo il codice relativo:

function il_maggiore($num1, $num2, $num3) {
  if (! is_numeric($num1) {
    return false;
  }
  if (! is_numeric($num2) {
    return false;
  }
  if (! is_numeric($num3) {
    return false;
  }
  if ($num1 > $num2) {
    if ($num1 > $num3) {
      return $num1;
    } 
    else {
      return $num3;
    }
  } 
  else {
    if ($num2 > $num3) {
      return $num2;
    } 
    else {
      return $num3;
    }
  }
} 

Come vediamo, la definizione della funzione avviene attraverso la parola chiave function, seguita dal nome che abbiamo individuato per la funzione, e dalle parentesi che contengono i parametri (o argomenti) che devono essere passati alla funzione. Di seguito, contenuto fra parentesi graffe, ci sarà il codice che viene eseguito ogni volta che la funzione viene richiamata. Il nome della funzione deve essere necessariamente univoco, questo significa che non è possibile definire due funzioni aventi lo stesso nome.

All'interno della funzione noterete l'istruzione return[...]; questa istruzione è molto importante, perchè termina la funzione (cioè restituisce il controllo allo script nel punto in cui la funzione è stata chiamata) e contemporaneamente determina anche il valore restituito dalla funzione. Nel nostro esempio, i tre dati ricevuti in input vengono controllati, uno dopo l'altro, per verificare che siano numerici: in caso negativo (il test infatti viene fatto facendo precedere la funzione is_numeric() dal simbolo "!" di negazione), la funzione termina immediatamente, restituendo il valore booleano FALSE.

Una volta verificato che i tre valori sono numerici, vengono posti a confronto i primi due, e poi quello dei due che risulta maggiore viene posto a confronto col terzo, per ottenere così il maggiore dei tre, che viene infine restituito come risultato della funzione. Quando sarà il momento di eseguire questa funzione potremo quindi usare questo codice:

$a = 9;
$b = 8;
$c = 15;
$m = il_maggiore($a, $b, $c); //$m diventa 15

Avete visto che abbiamo chiamato la funzione usando dei nomi di variabile diversi da quelli usati nella funzione stessa: la funzione infatti usa $num1, $num2, $num3, mentre lo script che la richiama utilizza $a, $b, $c. È molto importante ricordare che non c'è nessuna relazione definita tra i nomi degli argomenti che la funzione utilizza e quelli che vengono indicati nella chiamata. Ciò che determina la corrispondenza fra gli argomenti è, infatti, semplicemente la posizione in cui vengono indicati: nel nostro caso, quindi, $a diventerà $num1 all'interno della funzione, $b diventerà $num2 e $c diventerà $num3.

Avremmo potuto richiamare la nostra funzione anche passando direttamente i valori interessati, senza utilizzare le variabili:

$m = il_maggiore(9, 8, 15); //$m diventa 15
$m = il_maggiore(9, 8, 'ciao'); /* $m diventa FALSE, perchè il terzo argomento
non è numerico e quindi i controlli all'inizio della funzione bloccano l'esecuzione */

11_6.Dichiarazione di una Funzione

Quando si vuole costruire una funzione per renderla utilizzabile dai propri script PHP si ricorre a una sintassi di questo genere:

function nome_funzione(elenco_argomenti) { // blocco di istruzioni che implementano la // funzione // eventuale istruzione return }

Quando poi si vuole richiamare una funzione si può utilizzare una di queste sintassi:

// se la funzione restituisce un valore $variabile = nome_funzione(elenco_argomenti); // se la funzione non restituisce nulla nome_funzione(elenco_argomenti);

Vediamo immediatamente un esempio:

<?php function somma($a, $b) { return ($a + $b); } ?> <html> <head> <title>Dichiarare una funzione</title> </head> <body> <?php $valore1 = 10; $valore2 = 48; print("valore1 = $valore1 "); print("valore2 = $valore2 "); $somma = somma($valore1, $valore2); print("somma = $somma "); ?> </body> </html>

Guardando il codice dell'esempio si può notare come la dichiarazione della funzione sia stata inserita in un blocco PHP separato e in particolare in testa al file.

Sebbene questa sintassi non sia obbligatoria, è bene utilizzarla in quanto permette di raggruppare in un unico punto tutte le funzioni che verranno utilizzate all'interno dello script.

La funzione che abbiamo scritto riceve due parametri, le variabili $a e $b, e le utilizza per calcolare il risultato elaborativo per la quale è stata costruita, cioè la loro somma.

Questo risultato viene poi restituito al chiamante che lo userà per i suoi scopi, nel caso specifico il valore ritornato viene assegnato a una variabile che verrà successivamente stampata.

Occorre notare che il valore ritornato da una funzione può essere utilizzato direttamente come parametro per un'altra; infatti, nell'esempio precedente avremmo potuto tranquillamente scrivere il codice seguente:

print("somma = " . somma($valore1, $valore2) . " ");

senza scomodare altre variabili intermedie deputate unicamente a contenere il risultato dell'elaborazione.

In questo caso il valore restituito dalla funzione viene utilizzato direttamente per comporre la stringa che costituisce il parametro della funzione print().

11_7.Valori di ritorno in una Funzione

In linea generale esistono due tipologie di funzioni, quelle che restituiscono un valore e quelle che non lo restituiscono.

Nel primo caso, come abbiamo visto nell'esempio precedente, la funzione riceve un certo numero di parametri e, sulla base dei valori di questi parametri, costruisce un valore che viene poi restituito al chiamante attraverso l'istruzione return.

Nel secondo caso, invece, la funzione esegue il compito che le è stato assegnato e non restituisce nulla al chiamante: è il caso, per esempio, della funzione print(), che riceve come parametro una stringa e la stampa sullo standard output senza riportare nulla al frammento di script che ne ha richiesto l'esecuzione.

Esiste poi un terzo tipo di comportamento per il quale una funzione esegue un certo compito e successivamente restituisce al chiamante un codice di stato che identifica il successo dell'operazione o il suo fallimento.

Nel caso in cui ci sia da restituire un valore al chiamante si utilizza, come abbiamo detto, l'istruzione return che rappresenta anche il punto di uscita della funzione.

Per questo motivo è possibile avere più istruzioni return all'interno di una singola funzione se questo può essere utile a rendere più chiaro e pulito il codice. Vediamo un esempio:

<?php function operazione($a, $op, $b) { switch($op) { case "più": return ($a + $b); case "meno": return ($a - $b); case "per": return ($a * $b); case "diviso": return ($a / $b); default: return ("errore!"); } } ?> <html> <head> <title>Uso di return</title> </head> <body> <?php $valore1 = 10; $valore2 = 48; print("valore1 = $valore1 "); print("valore2 = $valore2 "); $operazioni = array ("più", "meno", "per", "diviso", "pippo"); foreach ($operazioni as $v) { print("$valore1 $v $valore2 = "); print(operazione($valore1, $v, $valore2)); print(" "); } ?> </body> </html>

Come si vede in questo esempio, nel corpo della funzione esistono più istruzioni return che consentono di uscire istantaneamente dalla funzione in qualsiasi punto del codice, indipendentemente da quello che viene dopo.

Ecco perché in questo caso all'interno di ogni singolo case del costrutto switch non è necessario inserire eventuali break. Un break, infatti, ha l'obiettivo di terminare il costrutto switch e riportare l'esecuzione subito dopo il costrutto stesso. Nel nostro caso, però, l'istruzione return è ancor più dirompente in quanto consente di uscire immediatamente dal corpo della funzione senza preoccuparsi del codice successivo.

Nella chiamata della funzione viene utilizzato il costrutto foreach per ciclare all'interno di un array contenente tutti i possibili valori che possono essere passati alla funzione come parametro che identifica l'operazione da eseguire. Tra questi ne è presente anche uno che non è gestito direttamente dalla funzione e quindi causa un errore applicativo che viene comunque gestito dal costrutto default dello switch.

Come si vede in questo esempio, e anche nel precedente, il valore di ritorno di una funzione è in sostanza il valore di un oggetto che viene costruito all'interno della funzione stessa e che viene poi propagato fuori dalla funzione al chiamante. In questo caso si tratta di una restituzione "per valore", nel senso che quello che viene effettivamente restituito è una copia del valore che quell'oggetto aveva all'interno della funzione.

Nel caso in cui sia necessario costruire un nuovo oggetto all'interno della funzione, e questo voglia essere restituito al chiamante come valore complesso per riferimento e non per copia, si utilizza una sintassi leggermente diversa:

function &getNewArray() { $newarray = array(); for($index=0; $index<50; $index++) { $newarray[] = rand(1,1000); } return($newarray); }

In questo caso, come si può vedere, la funzione restituisce lo stesso array che viene creato e arricchito all'interno della funzione stessa.

Per ottenere questo array già pronto si utilizza la sintassi:

$newarray = &getNewArray();

11_8.Visibilità in una Funzione

In generale, in uno script PHP non ci sono grossi problemi, a patto di comprendere le regole di visibilità delle variabili all'interno delle funzioni.

È bene comunque sapere che le variabili definite e utilizzate all'interno di una funzione sono visibili soltanto nella funzione stessa e non esistono fuori da quel contesto.

Vediamo un esempio:

<?php function setConto() { $contocorrente = "21316758/AB"; print ("Dentro la funzione il conto corrente è $contocorrente "); } ?> <html> <head> <title>Visibilità delle variabili</title> </head> <body> <?php $contocorrente = "41538983/FE"; setConto(); print ("Fuori dalla funzione il conto corrente è $contocorrente"); ?> </body> </html>

In questo esempio, si vede che all'interno della funzione setConto esiste la variabile $contocorrente che ha lo stesso nome di un'altra variabile utilizzata nello script che richiama la funzione stessa.

Questa situazione però non causa particolari problemi in quanto il motore di PHP utilizza, all'interno della funzione, la variabile definita nella funzione stessa e ignora l'esistenza di una variabile con lo stesso nome in un contesto più esterno.

D'altro canto, come già sappiamo, la chiamata alla funzione dall'interno dello script non ha nessun effetto sulla variabile $contocorrente; infatti la funzione print stampa correttamente il valore della variabile definita nello script.

Quindi, anche se il codice dell'esempio non è eccellente dal punto di vista della qualità e della pulizia, lo script funziona perfettamente e fa esattamente quello che ci si aspetta.

Global

Se dall'interno della funzione volessimo utilizzare la variabile definita esternamente, dovremmo utilizzare la seguente sintassi:

<?php function setConto() { $contocorrente = "21316758/AB"; print ("Dentro la funzione il conto corrente è $contocorrente "); global $contocorrente; print ("Dentro la funzione il conto corrente (global) è $contocorrente "); } ?>

In questo caso abbiamo utilizzato la parola chiave global per referenziare la variabile $contocorrente che abbiamo definito esternamente alla funzione, cioè all'interno dello script che richiama la funzione stessa.

Se guardiamo il risultato dell'esecuzione (Figura 4.4), appare chiaro il comportamento della parola chiave global: prima del suo utilizzo la funzione usa la variabile $contocorrente definita internamente; non appena viene utilizzata la global, il riferimento passa immediatamente alla variabile definita esternamente e da ora in poi viene utilizzata quella.

In questo modo è possibile referenziare una variabile definita a un livello più esterno.

Static

Negli esempi precedenti abbiamo visto che una variabile definita all'interno di una funzione esiste dal momento in cui viene utilizzata per la prima volta fino al momento in cui la funzione termina la sua esecuzione. Tecnicamente si dice che esiste solo nello stack di esistenza della funzione e quando viene eliminata dallo stack anche la variabile sparisce e la memoria che era precedentemente occupata dalla variabile stessa viene resa disponibile per altri oggetti.

A volte, però, può essere comodo avere variabili, definite all'interno di funzioni, che ricordino il valore che avevano la volta precedente in cui sono state utilizzate, anche nel contesto di altre chiamate di funzione e non solo, ovviamente, nella chiamata attuale.

Vediamo un esempio:

<?php function callCounter() { static $counter=0; $counter++; print ("La funzione callCounter è stata eseguita $counter volte. "); } ?> <html> <head> <title>Variabili Static</title> </head> <body> <?php for($i=0;$i<10;$i++) { callCounter(); } ?> </body> </html>

Analizzando l'output di questo script, si vede chiaramente che la variabile $counter viene inizializzata con il valore 0 soltanto la prima volta che la funzione viene chiamata, mentre dalla volta successiva la variabile mantiene il valore che aveva al termine della chiamata precedente.

In questo modo alla prima chiamata la variabile viene inizializzata al valore 0 e successivamente viene incrementata portando il suo valore a 1, valore che manterrà fino alla fine dell'esecuzione della funzione.

Alla seconda chiamata la variabile avrà il vecchio valore 1 e sarà incrementata nuovamente e così via fino alla fine del ciclo for.

Questo comportamento si ha grazie all'utilizzo della parola chiave static:

static $counter=0;

che viene interpretata dal motore PHP e che consente di memorizzare la variabile fuori dallo stack di esecuzione della funzione, in modo da non perderne il valore ed essere in grado di recuperarlo e utilizzarlo alla successiva chiamata.

11_9.Passaggio di parametri

Come abbiamo visto negli esempi precedenti, è possibile chiamare una funzione passandole parametri elaborativi che saranno utilizzati dalla funzione stessa per svolgere il suo compito.

La gestione dei parametri in PHP è molto flessibile, consentendo di passare alla funzione i valori dei parametri stessi (passaggio per valore) oppure i riferimenti agli oggetti reali che si vogliono modificare all'interno della funzione (passaggio per riferimento).

Contrariamente ad altri linguaggi sintatticamente più restrittivi, in PHP è possibile anche avere parametri facoltativi, senza i quali cioè la funzione esegue ugualmente il suo compito, e parametri con un valore predefinito, in modo che nel caso in cui un certo parametro non venga passato avrà comunque un valore preventivamente assegnato.

11_9_1.Passaggio di parametri per valore

Il passaggio per valore dei parametri di una funzione è il metodo classico utilizzato nella maggioranza dei casi.

Vediamo il seguente esempio:

<?php function swap($a, $b) { print("*** inizio della swap: a=$a - b=$b "); $temp=$a; $a=$b; $b=$temp; print("*** fine della swap: a=$a - b=$b "); } ?> <html> <head> <title>Parametri per valore</title> </head> <body> <?php $a=12; $b=34; print("Scambio di parametri (per valore) "); print("Valori iniziali: a=$a - b=$b "); swap($a,$b); print("Dopo la swap: a=$a - b=$b "); ?> </body> </html>

L'obiettivo di questo script è scrivere una funzione che prenda come parametri due variabili e scambi il contenuto tra queste appoggiandosi a una terza variabile temporanea.

La funzione agisce correttamente, ma a causa della modalità di passaggio dei parametri non è in grado di modificare realmente i valori delle variabili originali.

L'output di questo script è visibile nella Figura 4.6 e mostra come sia possibile passare alla funzione swap i parametri $a e $b e fare in modo che questa li possa utilizzare.

Quando però il controllo torna allo script chiamante, i parametri che sono stati passati alla funzione non hanno subito nessuna variazione in quanto quello che è stato passato alla funzione non è altro che una copia del valore delle due variabili $a e $b.

Il passaggio per valore, quindi, consente di passare a una funzione dei valori le cui modifiche, effettuate all'interno della funzione, vengono comunque perse, a meno che non siano memorizzate in altro modo attraverso l'utilizzo di variabili globali o di un database.

Quando si abbia la necessità di passare a una funzione una variabile che possa essere modificata realmente è necessario passare un riferimento alla variabile stessa.

Si utilizza allora il passaggio per riferimento.

11_9_2.Passaggio di parametri per riferimento

Il passaggio per riferimento dei parametri di una funzione è il metodo utilizzato quando è necessario permettere alla funzione chiamata la modifica diretta degli oggetti che le vengono passati come parametro.

Nel caso dell'esempio precedente, dove l'obiettivo è creare una funzione che scambi i valori di due variabili, se vogliamo che lo scambio venga eseguito realmente sulle variabili che abbiamo a disposizione nello script chiamante, è necessario passare il riferimento alle variabili e non una copia delle variabili stesse.

Ecco come dovrebbe essere riscritto il nostro script per funzionare come ci aspettiamo:

<?php function swap(&$a, &$b) { print("*** inizio della swap: a=$a - b=$b "); $temp=$a; $a=$b; $b=$temp; print("*** fine della swap: a=$a - b=$b "); } ?> <html> <head> <title>Parametri per riferimento</title> </head> <body> <?php $a=12; $b=34; print("Scambio di parametri (per riferimento) "); print("Valori iniziali: a=$a - b=$b "); swap($a,$b); print("Dopo la swap: a=$a - b=$b "); ?> </body> </html>

Ora lo script funziona correttamente e le due variabili di partenza vengono effettivamente scambiate.

Ciò è dovuto al fatto che nella dichiarazione della funzione ciascun nome di variabile è stato preceduto dal carattere & che indica che quella particolare variabile è stata passata per riferimento.

Questo comportamento è molto importante in quanto consente di passare variabili alle funzioni e di modificarle all'interno delle funzioni stesse.

Nel caso in cui sia necessario, per esempio, modificare contemporaneamente il valore di due variabili, non sarebbe possibile chiamare una funzione e utilizzare esclusivamente il valore da essa ritornato in quanto la modifica si limiterebbe a un valore alla volta. Se, invece, scrivessimo una funzione in grado di accettare due riferimenti, come nell'esempio precedente, saremmo in grado di modificare entrambi i valori e utilizzare magari il valore ritornato come test per verificare una condizione di successo o di errore.

La sintassi da utilizzare è quindi la seguente:

function nome_funzione(&$parametro1, $parametro2) { // corpo della funzione }

In questo caso $parametro1 viene passato per riferimento (si noti la presenza del carattere &), mentre $parametro2 viene passato per valore.

11_9_3.Valori di default per i parametri

In PHP è possibile scrivere funzioni con parametri facoltativi, il cui valore viene inizializzato direttamente nella dichiarazione della funzione e può essere utilizzato in caso di assenza del parametro durante una chiamata alla funzione stessa. Vediamo un esempio:

<?php function chiama($nome, $telefono="012345678") { print("Chiamata telefonica "); print("Nome: $nome "); print("Telefono: $telefono "); } ?> <html> <head> <title>Parametri con valore default</title> </head> <body> <?php chiama("Paperino","99999999999"); chiama("Topolino","88888888888"); chiama("Filiale"); ?> </body> </html>

Il risultato dell'esecuzione di questo script, dove appare chiaro come la chiamata alla funzione chiama si possa effettuare con entrambi i parametri $nome e $telefono, ma se quest'ultimo manca il suo valore viene prelevato direttamente dal valore di default, cioè quello indicato nella dichiarazione della funzione.

Questa è la ragione per cui non ci sono errori quando la funzione viene utilizzata passando un solo parametro e il valore utilizzato durante la composizione telefonica è corretto.

In questi casi la sintassi da utilizzare nella dichiarazione della funzione è la seguente:

function nome_funzione($parametro1, $parametro2=valore) { // corpo della funzione }

L'associazione diretta di un valore al $parametro2 consente di utilizzare quel valore in assenza di un passaggio esplicito da parte dello script chiamante.

11_9_4.Numero variabile di parametri

Un'altra caratteristica importante di PHP è la possibilità di definire funzioni con un numero non predeterminato di parametri: questo può essere molto utile in alcuni casi particolari e consente di scrivere codice pulito e semplice senza doversi appoggiare a strutture dati più complesse soltanto perché non si conosce a priori il numero dei possibili parametri che devono essere gestiti dalla funzione.

Supponiamo, per esempio, di voler scrivere una funzione che concateni un numero arbitrario di stringhe e restituisca al chiamante la stringa ottenuta dalla concatenazione.

Un metodo per risolvere questo problema potrebbe essere la definizione di una struttura dati, per esempio un array, contenente tutte le stringhe. Questo array potrebbe essere passato come parametro alla funzione che si potrebbe occupare di leggere tutti gli elementi e di concatenarli.

Una soluzione più semplice ed elegante consiste, invece, nel definire una funzione senza un numero predeterminato di parametri: la funzione non dovrà far altro che leggere tutti i parametri e concatenarli.

Vediamo un esempio di come si potrebbe realizzare:

<?php function concatena() { for($i=0;$i<func_num_args();$i++) { $result = $result . func_get_arg($i); } return $result; } ?> <html> <head> <title>Numero arbitrario di parametri</title> </head> <body> <?php print(concatena("un solo parametro ")); print(concatena("chiamata ","con tre ","parametri ")); print(concatena("questa ","è ","una ","chiamata ","con sei ","parametri ")); ?> </body> </html>

La funzione esegue correttamente la concatenazione indipendentemente dal numero di parametri con i quali viene chiamata.

Questo è possibile grazie a una serie di vincoli sintattici: innanzitutto la dichiarazione della funzione non deve contenere parametri espliciti. Nel nostro caso, infatti, la sintassi della dichiarazione è la seguente:

function concatena()

All'interno del corpo è poi possibile utilizzare alcune funzioni che ci danno informazioni utili, per esempio:

func_num_args(): restituisce il numero di parametri che sono stati passati alla funzione in quella particolare chiamata;
func_get_arg(i): restituisce il valore del parametro alla posizione i-esima dell'array contenente la lista dei parametri.

Con questi strumenti è possibile quindi scrivere funzioni che utilizzino un numero di parametri non predeterminato e che sono in grado quindi di svolgere compiti speciali come quello dell'esempio.

11_10.Funzioni ricorsive

Una funzione si dice ricorsiva se contiene nel suo corpo una chiamata a se stessa.

Il motore di PHP consente di scrivere funzioni ricorsive, cioè che richiamino direttamente se stesse, e questa caratteristica fornisce un ottimo strumento di programmazione in ambito matematico e non solo.

Il caso classico che viene studiato come algoritmo computazionale ricorsivo è quello che consente di calcolare il fattoriale di un numero attraverso la sua definizione matematica ricorsiva.

In matematica il fattoriale di un numero si definisce in questo modo: Il fattoriale di un numero n intero positivo è dato dalle due seguenti condizioni:

Condizione 1: n! = n * (n-1) * (n-2) * … * 3 * 2 * 1;
Condizione 2: 0! =1".

Se trasponiamo questa definizione in un algoritmo matematico ricorsivo abbiamo che il fattoriale di un numero n intero positivo è dato dalle due seguenti condizioni:

Condizione 1: n! = n * il fattoriale di (n-1);
Condizione 2: 0! =1.

Questo algoritmo è ovviamente implementabile attraverso l'utilizzo di una funzione ricorsiva. Vediamone un esempio:

<?php function fattoriale($n) { if ($n==0) { return 1; } else { return ($n * fattoriale($n-1)); } } ?> <html> <head> <title>Funzione ricorsiva</title> </head> <body> <?php for ($i=0;$i<10;$i++) { print("Il fattoriale di $i è "); print(fattoriale($i)); print(" "); } ?> </body> </html>

Come si può vedere, nel corpo dello script principale compare un ciclo for che richiama 10 volte la funzione fattoriale passandole come parametro un numero da 0 a 9.

La funzione fattoriale calcola il fattoriale del numero che le viene passato e lo restituisce al chiamante, ma per eseguire il calcolo effettua una chiamata ricorsiva a se stessa seguendo l'algoritmo matematico ricorsivo indicato in precedenza.

Questo è solo un esempio di come si possano implementare semplicemente con PHP sia funzioni ricorsive dirette, cioè che richiamano se stesse, sia funzioni ricorsive indirette, dove la funzione f1 chiama la funzione f2 e viceversa.

In generale, qualsiasi algoritmo ricorsivo può essere implementato utilizzando le funzioni ricorsive e questo con PHP è particolarmente semplice.

La sintassi utilizzata è la seguente:

function funzione_ricorsiva(parametri) { // corpo della funzione return funzione_ricorsiva(altri parametri); }

In questo modo, e senza stravolgere la sintassi, siamo in grado di utilizzare in PHP le funzioni ricorsive.

11_11.Chiamata a funzioni dinamiche

Abbiamo visto in precedenza come sia facile in PHP utilizzare variabili di variabili, cioè variabili il cui nome all'interno dello script è il valore di un'altra variabile.

Un'altra funzionalità molto interessante è la possibilità di chiamare funzioni il cui nome non è predefinito ma cambia in funzione del contesto che si avrà soltanto in fase di esecuzione.

Ecco un esempio di chiamata a funzioni dinamiche:

<?php function writeh1($text) { print("<h1>" . $text . "</h1>"); function writeh2($text) { print("<h2>" . $text . "</h2>"); function writeh3($text) { print("<h3>" . $text . "</h3>"); ?> <html> <head> <title>Funzioni dinamiche</title> </head> <body> <?php $funzione = "writeh1"; $funzione("Questo testo è scritto utilizzando il tag &lth1&gt"); $funzione = "writeh2"; $funzione("Questo testo è scritto utilizzando il tag &lth2&gt"); $funzione = "writeh3"; $funzione("Questo testo è scritto utilizzando il tag &lth3&gt"); ?> </body> </html>

In questo esempio si vede che il nome della funzione da chiamare viene assegnato a una variabile attraverso l'istruzione:

$funzione = "writeh1";

Da questo momento in poi è possibile chiamare la funzione writeh1 utilizzando al suo posto il nome della variabile che contiene il nome della funzione, grazie alla sintassi:

$funzione(parametri);

L'utilizzo delle funzioni dinamiche, esattamente come accade per le variabili di variabili, non è semplicissimo dal punto di vista funzionale. In realtà, la sintassi è molto comoda, quindi è possibile utilizzare questi potenti strumenti con semplicità quando si trovi un ambito funzionale compatibile.

12.Gestione delle eccezioni

Quando uno script PHP genera un errore, l'esecuzione si interrompe e tutto il risultato dell'elaborazione generato fino a quel momento viene spedito al browser per la visualizzazione, con tanto di indicazione di quale file ha causato l'errore e della linea che lo contiene.

Per capire come si comporta il motore PHP quando trova un errore di esecuzione vediamo questo esempio:

<html> <head> <title>Exit</title> </head> <body> <?php $maxrighe = 10; for ($indice=$maxrighe; $indice>=0; $indice--) { print("$maxrighe / $indice = " . ($maxrighe / $indice) . " "); } ?> </body> </html>

In questo momento, il nostro script è totalmente debole e insicuro in quanto nel momento in cui il valore del contatore, fornito dalla variabile $indice, diverrà uguale a zero avremo un errore di esecuzione.

Se provassimo infatti a eseguirlo, genererebbe un messaggio di errore con le indicazioni del file che lo ha generato e della linea dove si trova l'istruzione che lo ha causato.

Un software ben scritto dovrebbe prevedere una gestione degli errori preventiva, dove ogni zona del codice sia soggetta a controllo su tutte le possibili tipologie di errori che si possono verificare.

PHP fornisce allo scopo un completo sistema di controllo delle eccezioni, dove con il termine "eccezione" si intende proprio un errore, un comportamento anomalo dello script dovuto a cause spesso non prevedibili.

Vediamo come potrebbe essere scritto il codice del nostro esempio utilizzando la gestione delle eccezioni di PHP.

<html> <head> <title>Eccezioni</title> </head> <body> <?php $maxrighe = 10; for ($indice=$maxrighe; $indice>=-10; $indice--) { try { if($indice == 0) { throw new Exception (' la divisione per zero non è ammessa!!! '); } else { $risultato = $maxrighe / $indice; print("$maxrighe / $indice = " . ($risultato) . " "); } } catch(Exception $e) { Echo $e->getMessage(); } } ?> </body> </html>

In generale, la sintassi di uno script sottoposto a gestione degli errori è la seguente:

try { // istruzioni sottoposte a gestione delle eccezioni if(condizione di errore interno) { throw new MyException("Failure"); } // istruzioni sottoposte a gestione delle eccezioni } catch(MyException $e) { // istruzioni per il controllo // dell'eccezione personalizzata MyException } catch(Exception $e) { // istruzioni per il controllo di una generica // eccezione }

Quello che accade, in linea generale, è che ogni istruzione inserita in un blocco try viene eseguita con un occhio di riguardo alle possibili eccezioni che si possano scatenare, cioè ai possibili errori che possano verificarsi.

Se qualcosa non funziona e si verifica un'eccezione, il tutto passa immediatamente al blocco catch più vicino tra quelli in grado di trattare quel particolare tipo di eccezione; se non ce ne sono, si passa al blocco catch più vicino in grado di trattare un'eccezione generica.

Il blocco catch ha il compito di trattare l'errore che si è verificato ed eseguire le istruzioni necessarie al mantenimento di uno stato coerente nell'applicazione.