Guide per aspiranti programmatori

Fino a questo momento abbiamo sempre dato un nome alle nostre funzioni per poterle richiamare; in realtá, però, gli sviluppatori php sanno bene che esistono anche delle funzioni che non hanno un nome e che, per sequenza nel codice, (lettura ed esecuzione dall’alto verso il basso) non appena vengono “incontrate” si attivano: sono le cosiddette funzioni anonime.

Le funzioni anonime nascono per adempiere a due scopi specifici:

• essere assegnate ad una variabile (e, quindi, permetterci di richiamare la funzione utilizzando proprio il nome della variabile);
• essere utilizzate come funzioni di callback (ossia funzioni che vengono utilizzate come parametri reali di altre funzioni)

In questa situazione possiamo dire che il linguaggio php tratta le funzioni come un valore: un valore che puo essere assegnato ad una variabile oppure un valore che può essere passato come parametro reale ad un altra funzione;
quando una funzione accetta tra i suoi parametri a sua volta una funzione, o restituisce, come tipo di ritorno una funzione, viene detta “funzione di ordine superiore”

Vediamo qualche esempio ed utilizzo delle funzioni anonime:

<?php
  $sum = function($a, $b){
    return $a+$b;
  };
  echo $sum(4,5);
?>

In output avremo come risultato 9, vale a dire la corretta somma fra i due numeri.

La prima osservazione che possiamo fare, è che la nostra funzione ha un “;” dopo la graffa di chiusura; questo ci dice che quello che abbiamo scritto è un’espressione che verrà tradotta come una funzione e trattata come tale. 
Nel nostro esempio, abbiamo visto come una funzione anonima potrebbe essere sfruttata assegnandola ad una variabile, richiamandola attraverso la variabile stessa.

Con questa metodologia possiamo, anche, sfruttare parametri esterni alla funzione, facendoli entrare in un modo diverso rispetto a quanto abbiamo fatto fino ad ora

<?php
  $num1 = 5;
  $num2 = 12;
  $sum = function() use($num1, $num2){
    return $num1+$num2;
  };
  echo $sum();
?>

In output avremo come risultato 17, la corretta somma fra i due numeri.

Come vedi, con la keyword “use” diciamo alla funzione di utilizzare le variabili nello scope esterno.

La domanda sorge spontanea: adesso che conosciamo questa keyword, quindi, potremmo anche fare quanto a seguire?

<?php
  $num1 = 5;
  $num2 = 12;
  function sum() use($num1, $num2){
    return $num1+$num2;
  }
  sum();
?>

o ancora peggio

<?php
  $num1 = 5;
  $num2 = 12;

  function sum(use($num1, $num2)){
    return $num1+$num2;
  }
  sum();
?>

La risposta é assolutamente no!. 

In questi casi non possiamo utilizzare la keyword “use” perchè stiamo dichiarando la funzione tramite la keyword “function” e non come funzione anonima.
La differenza tra le due è che la funzione è un costrutto, la funzione anonima è una espressione tradotta e trattata come funzione; solo nel secondo caso possiamo utilizzare la keyword “use”.

Abbiamo detto che una funzione anonima può essere utilizzata come funzione di callback.
Ci sono funzioni built-in, ad esempio, che si aspettano come uno dei propri parametri una funzione di callback; vediamo una:

Array reduce, dalla documentazione: array_reduce() applica iterativamente la funzione di callback agli elementi dell’array, in modo da ridurlo ad un unico valore.

“array_reduce(array $array, callable $callback, mixed $initial = null): mixed”

Come vediamo, la nostra funzione si aspetta come secondo parametro una funzione di callback; useremo, quindi, una funzione anonima (l’ultimo parametro possiamo ometterlo):

<?php
  function sum(...$numbers){
    $result = array_reduce($numbers, function($accumulator, $number){
      return $accumulator += $number;
   });
  return $result;
  }

  $result = sum(3,56,78,6,13,7,89,100,95);
  echo $result;
  //In output avremo:
  //447
?>

Abbiamo costruito una funzione anonima all’interno dei parametri della funzione “array_reduce” che dovrá seguire delle regole ben specifiche descritte nella documentazione:

“callback(mixed $carry, mixed $item): mixed”

dove “carry” contiene il valore restituito dell’iterazione precedente (nel caso della prima iterazione mantiene, invece, il valore di initial), mentre “item” contiene il valore dell’iterazione corrente.

In soldoni, carry è il nostro accumulatore: una variabile che parte da un valore (null nel nostro caso) e, di volta in volta, verrà aggiornata con la somma dell’item, il nostro $number, il singolo numero catturato, in ordine da sinistra verso destra, dal nostro array di numeri $numbers.

Dunque, non abbiamo inventato dal nulla la nostra funzione di callback anonima: abbiamo seguito la documentazione e creato una funzione di conseguenza.
Attenzione! Le funzioni di callback non sono necessariamente funzioni anonime! 
Infatti, la documentazione PHP vanta anche numerosi esempi in cui non sono utilizzate funzioni anonime. Proviamo, quindi, a costruire il precedente esempio con una funzione standard:

<?php
  function callbackFunction($accumulator, $number){
    //return $accumalotor = $accumalotor + $number;
    return $accumulator += $number;
  };
  function sum(...$numbers){
    $result = array_reduce($numbers, "callbackFunction");
    return $result;
  }
  $result = sum(3,56,78,6,13,7,89,100,95);
  echo $result;

  //In output avremo:
  //447
?>

Possiamo dire che array reduce è un classico esempio diu fuzione di ordine superiore.