3  Le funzioni

3.1 Cos’è una funzione

Una funzione è un insieme di istruzioni che esegue un’operazione specifica. Evita di riscrivere lo stesso codice più volte: è sufficiente richiamarla, fornendole gli eventuali parametri di cui ha bisogno. Ogni funzione è caratterizzata da:

• un nome;

• i parametri richiesti (quali e quanti);

• il fatto di restituire o meno un valore.

nome_funzione(); // nessun parametro, nessun valore restituito
nome_funzione($a, $b); // due parametri
$valore = nome_funzione($a);  // il valore restituito viene salvato in una variabile

AvvisoAttenzione

Le parentesi tonde sono obbligatorie anche quando la funzione non richiede parametri.

Le funzioni possono essere built-in (incorporate nel linguaggio) oppure definite dall’utente.

3.2 Le funzioni built-in

PHP dispone di moltissime funzioni incorporate. Non è necessario impararle a memoria, ma è importante saper consultare il manuale ufficiale php.net: digitando https://www.php.net/nome_funzione si accede direttamente alla pagina della funzione.

NotaNota

Nel manuale ogni funzione è descritta nella forma tipo_restituito nome(parametri). I parametri indicati tra parentesi quadre [ ] sono opzionali.

Funzioni sulle variabili

• isset($var): TRUE se la variabile è definita e diversa da NULL;

• empty($var): TRUE se la variabile è vuota (stringa vuota, 0, NULL) oppure non definita;

• is_null($var): TRUE se il valore della variabile è NULL;

• is_int($var), is_float($var), is_string($var), is_array($var): TRUE se la variabile è, rispettivamente, un intero, un decimale, una stringa, un array;

• is_numeric($var): TRUE se la variabile è un numero oppure una stringa che contiene un numero;

• unset($var): distrugge la variabile (è un costrutto del linguaggio, non una vera funzione). Dopo l’unset, isset restituisce FALSE ed empty restituisce TRUE;

• print_r($var): stampa il contenuto di una variabile o di un array (utile per il debug, vedi sezione precedente).

$a = 5;
$b = isset($a);        // TRUE
$b = is_int($a);       // TRUE
$b = is_float($a);     // FALSE
    
$a = '5';
$b = is_int($a);       // FALSE: ora $a contiene una stringa
$b = is_string($a);    // TRUE
$b = is_numeric($a);   // TRUE: la stringa contiene un numero
    
unset($a);
$b = isset($a);        // FALSE: variabile distrutta
    
// utilizzo tipico: condizione di un if
if (empty($a)) {
    echo "Variabile vuota o non definita";
} else {
    echo "La variabile contiene un valore";
    }

Funzioni sulle stringhe

• strlen($str): restituisce la lunghezza della stringa in byte. Con testo UTF-8 contenente caratteri accentati, per contare i caratteri si usa mb_strlen() se l’estensione mbstring è disponibile;

• trim($str), ltrim($str), rtrim($str): eliminano gli spazi rispettivamente all’inizio e alla fine, solo all’inizio, solo alla fine della stringa;

• ucfirst($str): porta in maiuscolo il primo carattere della stringa;

• ucwords($str): porta in maiuscolo il primo carattere di ogni parola;

• strtolower($str), strtoupper($str): convertono tutta la stringa in minuscolo o in maiuscolo;

• str_replace($cerca, $sostituisci, $str): sostituisce nella stringa tutte le occorrenze di $cerca con $sostituisci (str_ireplace ignora la differenza tra maiuscole e minuscole);

• strpos($str, $cerca): restituisce la posizione (a partire da 0) della prima occorrenza di $cerca, oppure FALSE se non è presente (stripos ignora maiuscole e minuscole);

• strstr($str, $cerca): restituisce la parte di stringa che parte dalla prima occorrenza di $cerca, oppure FALSE (stristr ignora maiuscole e minuscole);

• substr($str, $inizio [, $lunghezza]): restituisce una porzione della stringa.

Il funzionamento di substr dipende dai valori dei parametri:

• i caratteri si contano a partire da 0;

• se $inizio è negativo si parte dalla fine (-1 è l’ultimo carattere);

• se $lunghezza è omessa si arriva fino alla fine della stringa;

• se $lunghezza è negativa indica quanti caratteri escludere dalla fine.

$s = "  ciao mondo  ";
echo strlen($s);                  // 14
$s = trim($s);                    // "ciao mondo"
echo ucfirst($s);                 // Ciao mondo
echo ucwords($s);                 // Ciao Mondo
echo strtoupper($s);              // CIAO MONDO
echo str_replace("o", "0", $s);   // cia0 m0nd0
echo strpos($s, "mondo");         // 5
echo strstr("Lorenzo", "re");     // renzo
    
echo substr("Lorenzo", 4);        // nzo
echo substr("Lorenzo", -3, 2);    // nz
echo substr("Lorenzo", 1, -2);    // oren

AvvisoAttenzione

strpos restituisce 0 se la stringa cercata si trova all’inizio, ma 0 e false sono valori uguali per l’operatore ==. Per verificare se la ricerca è riuscita si usa l’operatore !==:

if (strpos("Lorenzo", "Lo") !== false) {
    echo "Trovato";
}

Funzioni sugli array

• count($array) (o sizeof): restituisce il numero di elementi dell’array;

• array_reverse($array [, $preserve_keys]): restituisce l’array con gli elementi in ordine inverso. Con TRUE come secondo parametro le chiavi vengono mantenute;

• sort($array), rsort($array): ordinano l’array in modo crescente o decrescente;

• in_array($valore, $array): TRUE se il valore è presente nell’array;

• array_key_exists($chiave, $array): TRUE se la chiave è presente nell’array;

• array_search($valore, $array): restituisce la chiave del valore trovato, oppure FALSE;

• array_merge($array1, $array2 [, ...]): unisce due o più array. Le chiavi numeriche vengono rinumerate; per le chiavi associative uguali, l’ultimo valore sovrascrive i precedenti;

• array_push($array, $valore [, ...]): aggiunge uno o più valori in fondo all’array;

• array_pop($array): rimuove e restituisce l’ultimo elemento;

• array_unshift($array, $valore [, ...]): aggiunge uno o più valori all’inizio dell’array;

• array_shift($array): rimuove e restituisce il primo elemento (gli indici numerici vengono rinumerati);

• explode($separatore, $str): trasforma una stringa in un array, dividendola in base al separatore;

• implode($separatore, $array): trasforma un array in una stringa, inserendo il separatore tra gli elementi.

AvvisoAttenzione

Le funzioni sort, rsort, array_push, array_pop, array_shift e array_unshift modificano direttamente l’array passato come parametro: l’ordine o il contenuto originale va perso. Dopo sort e rsort le chiavi originali vengono eliminate e sostituite da indici numerici a partire da 0.

$numeri = [4, 9, 1];
echo count($numeri);             // 3
sort($numeri);                   // 1, 4, 9
array_push($numeri, 7);          // 1, 4, 9, 7
$ultimo = array_pop($numeri);    // $ultimo = 7      -> 1, 4, 9
$primo = array_shift($numeri);   // $primo = 1       -> 4, 9
array_unshift($numeri, 0);       // 0, 4, 9
    
var_dump(in_array(4, $numeri));  // bool(true)
echo array_search(9, $numeri);   // 2
    
$c = array_merge([1, 2], [3, 4]);        // 1, 2, 3, 4
$parole = explode(" ", "ciao Mario");    // ["ciao", "Mario"]
$testo = implode("-", $parole);          // "ciao-Mario"

Come per strpos(), il risultato di array_search() deve essere confrontato con false usando !== quando si vuole sapere se il valore è stato trovato.

Funzioni sulle date

Le funzioni sulle date si basano sul timestamp: un numero intero che rappresenta i secondi trascorsi dal 1° gennaio 1970.

• time(): restituisce il timestamp del momento in cui viene eseguita;

• date($formato [, $timestamp]): restituisce una stringa con la data formattata secondo il formato indicato. Se il timestamp è omesso, usa quello attuale;

• mktime($ora, $minuti, $secondi, $mese, $giorno, $anno): calcola il timestamp di una data. Se un valore supera il proprio limite, PHP lo riporta nell’intervallo corretto, ad esempio il mese 14 diventa febbraio dell’anno successivo. Questo permette di eseguire calcoli sulle date;

• checkdate($mese, $giorno, $anno): TRUE se i valori formano una data valida.

I principali codici per il formato di date:

Codice	Significato	Codice	Significato
Y	anno (4 cifre)	d	giorno del mese (01–31)
y	anno (2 cifre)	j	giorno del mese (1–31)
m	mese (01–12)	w	giorno della settimana (0 = dom, 6 = sab)
n	mese (1–12)	l	giorno della settimana testuale
F	mese testuale (January)	D	giorno della settimana su 3 lettere
M	mese su 3 lettere (Jan)	H	ora (00–23)
i	minuti (00–59)	G	ora (0–23)
s	secondi (00–59)

echo time();                          // timestamp attuale
echo date("d/m/Y");                   // data attuale, es. 24/09/2026
echo date("H:i:s");                   // ora attuale, es. 10:30:15
echo date("d/m/Y", mktime(0, 0, 0, 14, 1, 2026));   // 01/02/2027
var_dump(checkdate(2, 30, 2026));     // bool(false)

AvvisoAttenzione

I parametri di mktime hanno un ordine particolare (ora, minuti, secondi, mese, giorno, anno) che porta facilmente a errori.

I timestamp non contengono informazioni sul fuso orario. Per applicazioni reali è preferibile utilizzare DateTimeImmutable e impostare esplicitamente il fuso:

$oraRoma = new DateTimeImmutable("now", new DateTimeZone("Europe/Rome"));
echo $oraRoma->format("d/m/Y H:i:s");

ConsiglioDate moderne

DateTimeImmutable restituisce nuovi oggetti quando si modifica una data, evitando cambiamenti accidentali dell’oggetto originale. È generalmente preferibile per elaborazioni non banali.

3.3 Le funzioni definite dall’utente

Quando una stessa sequenza di istruzioni deve essere ripetuta più volte, è consigliabile definire una funzione propria. I vantaggi sono un codice più leggibile, più compatto e più facile da mantenere. La sintassi è la seguente:

function nomeFunzione($parametro1, $parametro2 = valoreDefault) {
    <blocco di istruzioni>
    return <espressione>;   // opzionale
}

Le parentesi graffe sono obbligatorie. Le dichiarazioni di tipo dei parametri e del valore restituito sono facoltative, ma rendono il contratto della funzione più chiaro e permettono a PHP di rilevare utilizzi errati.

function saluta($nome) {
    return "Ciao " . $nome;
}
    
echo saluta("Mario");   // Ciao Mario

La stessa funzione può essere dichiarata specificando i tipi:

function saluta(string $nome): string {
    return "Ciao " . $nome;
}

Parametri con valore di default

Se a un parametro viene assegnato un valore di default nella definizione, il parametro diventa facoltativo: se nella chiamata manca, la funzione usa il valore di default. I parametri facoltativi vanno indicati dopo quelli obbligatori.

function anagrafe($nome, $indirizzo, $cf = "non disponibile") {
    echo "Nome: " . $nome . "<br>";
    echo "Indirizzo: " . $indirizzo . "<br>";
    echo "Codice fiscale: " . $cf . "<br>";
}
    
anagrafe("Mario Rossi", "via Roma 2", "RSSMRA69S12A944X");
anagrafe("Paolo Verdi", "via Parigi 9");   // codice fiscale: non disponibile

Passaggio dei parametri: per valore e per riferimento

• Per valore (default): la funzione lavora su una copia della variabile, quindi la variabile originale non viene modificata;

• Per riferimento: la funzione lavora sulla variabile originale, che può quindi essere modificata. Si ottiene anteponendo il simbolo & al parametro nella definizione della funzione.

Nella chiamata il simbolo & non va indicato.

function quadrato($a) {
    $a = $a * $a;
}
    
function quadratoRif(&$a) {
    $a = $a * $a;
}
    
$b = 2;
quadrato($b);
echo $b;          // 2: passaggio per valore, $b non cambia
quadratoRif($b);
echo $b;          // 4: passaggio per riferimento, $b viene modificata

Il costrutto return

L’istruzione return (opzionale) restituisce un solo valore al chiamante e termina l’esecuzione della funzione.

function divisione($num1, $num2) {
    if ($num2 == 0) {
            return FALSE;   // la funzione termina qui
    }
    return $num1 / $num2;
}
    
$m = divisione(4, 2);   // 2
$m = divisione(5, 0);   // FALSE

AvvisoAttenzione

Poiché 0 e false sono uguali per l’operatore ==, per controllare l’esito della funzione precedente si usa $m === false.

Per restituire più valori si può restituire un array, che il chiamante può scomporre con list() o con la sintassi abbreviata []. Nella forma posizionale gli elementi vengono associati a partire dall’indice 0.

function calcola($a, $b) {
    return array($a * 10, $b * 100);
}
    
list($x, $y) = calcola(2, 3);   // $x = 20, $y = 300
[$x, $y] = calcola(2, 3);       // sintassi abbreviata equivalente

Visibilità (scope) delle variabili

Le variabili usate all’interno di una funzione sono locali: esistono solo nella funzione e sono diverse da quelle definite all’esterno, anche se hanno lo stesso nome.

function raddoppia($num) {
    $temp = $num * 2;
}
    
raddoppia(5);
echo $temp;   // ERRORE: $temp esiste solo dentro la funzione

Per utilizzare all’esterno un valore calcolato in una funzione, bisogna restituirlo con return:

function raddoppia($num) {
    return $num * 2;
}
    
$temp = raddoppia(5);
echo "Risultato: " . $temp;   // Risultato: 10

NotaNota

Fanno eccezione le variabili superglobali (come $_GET e $_POST), che sono accessibili in qualsiasi punto dello script, anche all’interno delle funzioni.

Riuso delle funzioni: include e require

Le funzioni utili in più pagine si scrivono in un file separato, che viene poi importato con le istruzioni include e require.

File funzioni.php:

<?php
function grassetto(string $stringa): string {
    return "<strong>" . $stringa . "</strong>";
}

File main.php:

<?php
require_once "funzioni.php";
echo grassetto("testo in grassetto");

La differenza tra le due istruzioni riguarda il comportamento in caso di errore (file non trovato):

• include: genera un warning e lo script continua;

• require: genera un errore fatale e lo script si interrompe.

Le varianti include_once e require_once importano il file una sola volta, evitando l’errore causato dalla ridefinizione delle stesse funzioni.

3.4 Esercizi

1. Scrivere una funzione isPari(int $numero): bool che stabilisca se un numero è pari.
2. Scrivere una funzione che riceva nome e cognome e restituisca una stringa formattata con le iniziali maiuscole.
3. Scrivere una funzione che riceva un array di numeri e ne restituisca minimo, massimo e media.
4. Scrivere una funzione con un parametro facoltativo per generare un messaggio di saluto formale oppure informale.
5. Dimostrare con un esempio la differenza tra passaggio per valore e passaggio per riferimento.
6. Separare alcune funzioni in funzioni.php e importarle in una seconda pagina usando require_once.
7. Creare un oggetto DateTimeImmutable relativo al fuso Europe/Rome e stampare data e ora nei formati italiano e ISO 8601.

AvvisoIstruzioni di consegna

Consegnare ogni esercizio in un file PHP diverso e numerato. Inserire tutti i file in una cartella denominata cognome_nome e consegnarla in formato compresso.