Funzioni personalizzate in PHP

Le funzioni sono uno degli strumenti più importanti a disposizione in un linguaggio di programmazione. Finora abbiamo visto quelle predefinite che PHP mette a disposizione nativamente, come per esempio le funzioni per manipolare le stringhe o gli array.

Ora impareremo a creare nostre funzioni da zero (funzioni UDF o user-defined functions). Prima di procedere, però, diamo una definizione di funzione:

Una funzione è un insieme di istruzioni che consentono di eseguire una determinata operazione.

Una funzione può prendere in ingresso dei parametri e restituire un risultato. Sia l'input che l'output sono opzionali, possono esistere funzioni che eseguono delle istruzioni senza bisogno di parametri e senza bisogno di restituire un valore di ritorno.

Creare una funzione

Una semplice funzione può essere definita come segue:

function somma($a, $b) {
    return $a + $b;
}

Il codice che abbiamo visto crea una funzione chiamata somma che restituisce appunto la somma di due parametri. Vediamo in dettaglio come definire una funzione:

• una funzione inizia sempre con la parola riservata function;
• deve seguire il nome che vogliamo dare alla funzione, in questo caso somma, il nome deve essere univoco e non può essere uguale ad una delle funzioni già messe a disposizione da PHP;
• deve contenere i parametri in ingresso all'interno di parentesi tonde, nel nostro caso $a e $b, nel caso in cui non ci siano parametri è sufficiente usare le sole parentesi tonde;
• tutte le istruzioni devono essere racchiuse all'interno di parentesi graffe {};
• nel caso in cui la funziona restituisca un risultato, esso deve essere restituito con la parola riservata return.

Per eseguire una funzione da noi creata la modalìtà è la stessa con cui richiamiamo le funzioni native di PHP, cioè richiamandola nel punto in cui vogliamo eseguirla:

echo "La somma di 5 e 4 è: " . somma(5, 4);

L'esempio in alto restuirà come output:

La somma di 5 e 4 è: 9

I parametri passati in ingresso ad una funzione possono anche essere opzionali se definiamo un valore di default. Supponiamo che il secondo parametro della funziona sia opzionale e, se non definito, sia di default 10, potremmo a quel punto richiamare la nostra funzione passando solo il primo parametro. Automaticamente PHP sommerà al nostro primo parametro il valore 10:

function somma($a, $b = 10) {
    return $a + $b;
}

Il codice della funzione è lo stesso, l'unica cosa che cambia è il valore di inizializzazione della variabile $b. Eseguendo il codice:

echo "La somma di 5 e 10 è: " . somma(5);

L'output sarà:

La somma di 5 e 10 è: 15

Ora che abbiamo visto come creare una funzione e come definire parametri opzionali possiamo provare a creane una leggermente più complessa.

Supponiamo di voler creare una funzione che, dato in ingresso un array di interi ed un valore numerico, restituisca l'array con i valori moltiplicati per il secondo parametro.

Avremo bisogno di ciclare l'array (chiamiamolo $array) e di moltiplicarne il valore dei singoli elementi per un secondo parametro (chiamiamolo $moltiplicatore). A questo punto la funzione restituirà un nuovo array.

function moltiplica_array($array, $moltiplicatore = 2) {
    $nuovo_array = [];
    foreach($array as $elemento) {
        $nuovo_array[] = $elemento * $moltiplicatore;
    }
    return $nuovo_array;
}
print_r( moltiplica_array([1, 2, 5, 10], 5) );

La funzione appena vista restituirà un output come il seguente:

Array
(
    [0] => 5
    [1] => 10
    [2] => 25
    [3] => 50
)

ovvero i singoli valori dell'array iniziale moltiplicati per 5. Se invece richiamassimo la funzione senza il secondo parametro, i valori dell'array restituito verranno moltiplicati per 2.

Funzioni anonime

Abbiamo appena visto che per creare una funzione è necessario definine un nome univoco. In realtà non è del tutto vero e possiamo creare anche funzioni anonime che possono essere utilizzate in casi particolari dove, ad esempio, la funzione viene passata come parametro ad un'altra funzione. È sconsigliabile invece utilizzarla nel caso di funzioni da richiamare in più punti della nostra applicazione, non avendo un nome sarebbe impossibile richiamarla.

Per vedere un esempio di utilizzo di funzioni anonime riprendiamo la lezione relativa alle espressioni regolari. Nella lezione abbiamo introdotto la funzione preg_replace_callback() che si occupa di effettuare delle sostituzioni in una stringa attraverso una funzione di callback. L'esempio che avevamo utilizzato in quel caso era quello di trasformare una URL di YouTube nel suo codice di embed per mostrarlo all'interno di una pagina. Lo script era il seguente:

$youtubeUrl = 'https://www.youtube.com/watch?v=1cQh1ccqu8M';
$youtubePattern = "/\s*[a-zA-Z\/\/:\.]*youtu(be.com\/watch\?v=|.be\/)([a-zA-Z0-9\-_]+)([a-zA-Z0-9\/\*\-\_\?\&\;\%\=\.]*)/i";
function youtubeEmbedCallback($matches) {
    if (!isset($matches[2])) {
        return '';
    }
    $videoId = $matches[2];
    return '<iframe width="560" height="315" src="https://www.youtube.com/embed/' . $videoId . '" frameborder="0" allowfullscreen></iframe>';
}
$youtubeEmbed = preg_replace_callback($youtubePattern, "youtubeEmbedCallback", $youtubeUrl);
echo $youtubeEmbed;

Essa prende in ingresso come secondo parametro il nome della funzione da utilizzare per le sostituzioni. Questo è un classico esempio in cui è utile una funzione anonima: anziché passare il nome di una funzione e definirla in precedenza, possiamo passarne direttamente una anonima. Vediamo l'esempio:

$youtubeUrl = 'https://www.youtube.com/watch?v=1cQh1ccqu8M';
$youtubePattern = "/\s*[a-zA-Z\/\/:\.]*youtu(be.com\/watch\?v=|.be\/)([a-zA-Z0-9\-_]+)([a-zA-Z0-9\/\*\-\_\?\&\;\%\=\.]*)/i";
$youtubeEmbed = preg_replace_callback($youtubePattern, function($matches) {
    if (!isset($matches[2])) {
        return '';
    }
    $videoId = $matches[2];
    return '<iframe width="560" height="315" src="https://www.youtube.com/embed/' . $videoId . '" frameborder="0" allowfullscreen></iframe>';
}, $youtubeUrl);
echo $youtubeEmbed;

Come abbiamo visto dal codice, la funzione viene definita senza nome ma con gli stessi parametri che vengono passati nel primo esempio.