Arrow function in PHP: sintassi fn() => ed esempi

Una arrow function è una breve funzione anonima: fn($x) => $x * 2. Il corpo dopo => è una singola espressione il cui valore viene restituito, e ogni variabile del codice circostante usata dall'espressione viene catturata automaticamente, per valore. Le arrow function esistono da PHP 7.4 e si usano soprattutto come callback.

<?php
$double = fn($x) => $x * 2;
echo $double(21), "\n";

$prices = [10, 25, 40];
print_r(array_map(fn($p) => $p * 1.2, $prices));

$rate = 0.9;   // used inside without "use"
print_r(array_map(fn($p) => $p * $rate, $prices));

La sintassi

fn, la lista dei parametri, =>, un'espressione. I tipi dei parametri, i valori di default e il tipo restituito funzionano come nelle funzioni normali:

<?php
$add = fn(int $a, int $b = 1): int => $a + $b;
$greet = fn(string $name): string => "Hello, $name";
$isEven = fn(int $n): bool => $n % 2 === 0;
$now = fn() => 'no parameters';

echo $add(2, 3), ' ', $add(2), "\n";
echo $greet('Ada'), "\n";
var_dump($isEven(4), $isEven(7));
echo $now(), "\n";

// Call it immediately
echo (fn($x) => $x ** 2)(9), "\n";

Non c'è la parola chiave return e non ci sono graffe. Un'espressione lunga si può comunque dividere su più righe per leggibilità.

Le variabili esterne vengono catturate per valore

Una arrow function vede ogni variabile dello scope in cui viene creata. Ne copia i valori in quel momento. Le modifiche fatte dentro restano dentro, e le modifiche fatte fuori dopo la creazione della funzione non vengono viste:

<?php
$count = 0;
$increment = fn() => ++$count;

echo $increment(), "\n";   // works on its own copy
echo $increment(), "\n";   // a fresh copy each call
echo $count, "\n";         // the outer variable is unchanged

$discount = 10;
$apply = fn($price) => $price - $discount;
$discount = 50;            // too late: 10 was already captured
echo $apply(100), "\n";

È la differenza principale rispetto a function () use (&$count), che può condividere una variabile per riferimento. Una arrow function non può riassegnare una variabile esterna. Può comunque modificare un oggetto che ha catturato (la copia è un riferimento allo stesso oggetto), e un parametro dichiarato per riferimento funziona come in qualsiasi funzione: fn(array &$list) => $list[] = 'x'.

Callback per array_map, array_filter e usort

La maggior parte delle funzioni per array accetta una callback, ed è lì che le arrow function eliminano più rumore. Confronta lo stesso filtro scritto nei due modi:

<?php
$users = [
    ['name' => 'Ada', 'age' => 36, 'active' => true],
    ['name' => 'Linus', 'age' => 28, 'active' => false],
    ['name' => 'Grace', 'age' => 45, 'active' => true],
];

// Long form
$active1 = array_filter($users, function ($u) {
    return $u['active'];
});

// Arrow function
$active2 = array_filter($users, fn($u) => $u['active']);
var_dump($active1 === $active2);

$names = array_map(fn($u) => $u['name'], $active2);
echo implode(', ', $names), "\n";

usort($users, fn($a, $b) => $a['age'] <=> $b['age']);
echo implode(', ', array_column($users, 'name')), "\n";

$total = array_reduce($users, fn($sum, $u) => $sum + $u['age'], 0);
echo "Total age: $total\n";

<=> restituisce -1, 0 o 1, esattamente ciò che vuole usort(), quindi ordinare per un campo sta in una riga. Scambia $a e $b per l'ordine decrescente.

Arrow function che restituiscono arrow function

Le variabili catturate includono i parametri di una arrow function che la contiene, quindi puoi annidarle per costruire funzioni a partire da altri valori:

<?php
$multiplyBy = fn($factor) => fn($x) => $x * $factor;

$triple = $multiplyBy(3);
$tenTimes = $multiplyBy(10);

echo $triple(5), ' ', $tenTimes(5), "\n";

$between = fn($min, $max) => fn($n) => $n >= $min && $n <= $max;
$teen = $between(13, 19);
print_r(array_filter([8, 13, 16, 21, 19], $teen));

Nota che array_filter() mantiene le chiavi originali, ed è per questo che il risultato parte dall'indice 1.

fn vs function: quando serve una closure completa

Le arrow function smettono di funzionare quando il corpo richiede più di un'espressione o deve modificare una variabile esterna. Allora usa una funzione anonima:

<?php
$orders = [120, 45, 300, 80];

// Needs a statement and an outer total: a closure with use (&...)
$total = 0;
$big = [];
array_walk($orders, function ($amount) use (&$total, &$big) {
    $total += $amount;
    if ($amount > 100) {
        $big[] = $amount;
    }
});
echo "Total $total, big orders: ", implode(', ', $big), "\n";

// The same result split into expressions: arrow functions fit again
$total2 = array_sum($orders);
$big2 = array_values(array_filter($orders, fn($a) => $a > 100));
echo "Total $total2, big orders: ", implode(', ', $big2), "\n";

Quando una arrow function sembra stretta, spesso significa che il lavoro è in realtà due lavori. Dividerlo in un filtro e una somma, come sopra, mantiene ogni callback una singola espressione.