Fonctions fléchées PHP : syntaxe fn() => et exemples

Une fonction fléchée est une fonction anonyme courte : fn($x) => $x * 2. Le corps après => est une seule expression dont la valeur est renvoyée, et toute variable du code environnant utilisée par l'expression est capturée automatiquement, par valeur. Les fonctions fléchées existent depuis PHP 7.4 et servent surtout de callbacks.

<?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 syntaxe

fn, la liste de paramètres, =>, une expression. Les types de paramètres, les valeurs par défaut et le type de retour fonctionnent comme dans les fonctions normales :

<?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";

Il n'y a ni mot-clé return ni accolades. Une longue expression peut quand même être répartie sur plusieurs lignes pour la lisibilité.

Les variables extérieures sont capturées par valeur

Une fonction fléchée voit toutes les variables de la portée où elle est créée. Elle copie leurs valeurs à ce moment-là. Les modifications faites à l'intérieur restent à l'intérieur, et celles faites à l'extérieur après la création de la fonction ne sont pas vues :

<?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";

C'est la principale différence avec function () use (&$count), qui peut partager une variable par référence. Une fonction fléchée ne peut pas réaffecter une variable extérieure. Elle peut quand même modifier un objet qu'elle a capturé (la copie est une poignée vers le même objet), et un paramètre déclaré par référence fonctionne comme dans toute fonction : fn(array &$list) => $list[] = 'x'.

Callbacks pour array_map, array_filter et usort

La plupart des fonctions de tableau prennent un callback, et c'est là que les fonctions fléchées allègent le plus le code. Comparez un même filtre écrit des deux façons :

<?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";

<=> renvoie -1, 0 ou 1, exactement ce qu'attend usort(), donc trier par un champ tient sur une ligne. Échangez $a et $b pour trier dans l'ordre décroissant.

Des fonctions fléchées qui renvoient des fonctions fléchées

Les variables capturées incluent les paramètres d'une fonction fléchée englobante, vous pouvez donc les imbriquer pour construire des fonctions à partir d'autres valeurs :

<?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));

Remarquez qu'array_filter() garde les clés d'origine, c'est pourquoi le résultat commence à l'index 1.

fn ou function : quand il faut une closure complète

Les fonctions fléchées ne suffisent plus quand le corps a besoin de plus d'une expression ou doit modifier une variable extérieure. Utilisez alors une fonction anonyme :

<?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";

Quand une fonction fléchée semble à l'étroit, c'est souvent que le travail en contient deux. Le séparer en un filtre et une somme, comme ci-dessus, garde chaque callback à une seule expression.