Fonctions anonymes et closures PHP : le mot-clé use

Une fonction anonyme, aussi appelée closure, est une fonction sans nom. Vous écrivez function ($param) { ... } là où une valeur est attendue : l'affecter à une variable, la passer à une autre fonction ou la renvoyer. Elle peut emporter des variables du code environnant avec use ($var).

<?php
$greet = function (string $name): string {
    return "Hello, $name";
};   // the semicolon ends the assignment

echo $greet('Ada'), "\n";

$greeting = 'Welcome';
$welcome = function (string $name) use ($greeting): string {
    return "$greeting, $name";
};
echo $welcome('Linus'), "\n";

var_dump($greet instanceof Closure);

Chaque fonction anonyme est un objet de la classe native Closure, c'est pourquoi elle peut être stockée, transmise et appelée plus tard avec $greet(...).

Le mot-clé use capture par valeur

Une closure ne voit pas d'elle-même les variables extérieures. use ($x) copie la valeur de $x dans la closure au moment où la closure est créée, pas quand elle s'exécute :

<?php
$discount = 10;

$apply = function (float $price) use ($discount): float {
    return $price - $discount;
};

$discount = 50;            // changed after the closure was created
echo $apply(100), "\n";    // still uses 10

// Several variables
$currency = 'EUR';
$rate = 1.08;
$convert = function (float $usd) use ($rate, $currency): string {
    return number_format($usd / $rate, 2) . " $currency";
};
echo $convert(54), "\n";

use par référence : &$var

use (&$x) donne à la closure la variable elle-même plutôt qu'une copie. Les modifications faites dans la closure sont visibles à l'extérieur, et celles faites à l'extérieur sont vues à l'intérieur. C'est ainsi qu'un callback ajoute à un total ou tient un compteur.

<?php
$total = 0;
$addToTotal = function (int $amount) use (&$total): void {
    $total += $amount;
};

$addToTotal(10);
$addToTotal(32);
echo $total, "\n";

// A counter that remembers its state between calls
function makeCounter(): Closure
{
    $count = 0;
    return function () use (&$count): int {
        return ++$count;
    };
}

$next = makeCounter();
echo $next(), $next(), $next(), "\n";

$other = makeCounter();     // its own $count
echo $other(), "\n";

Chaque appel à makeCounter() crée un nouveau $count, et la closure renvoyée le garde en vie après le retour de la fonction. C'est ce que désigne « closure » : la fonction se referme sur les variables dont elle a besoin.

Passer une closure en callback

Des fonctions comme array_map(), array_filter(), usort() et array_walk() prennent une fonction en argument. Une closure permet de l'écrire sur place, avec autant d'instructions que nécessaire :

<?php
$products = [
    ['name' => 'Laptop', 'price' => 1200, 'stock' => 3],
    ['name' => 'Mouse', 'price' => 25, 'stock' => 0],
    ['name' => 'Monitor', 'price' => 300, 'stock' => 7],
];

$minPrice = 100;
$available = array_filter($products, function ($p) use ($minPrice) {
    return $p['stock'] > 0 && $p['price'] >= $minPrice;
});

usort($available, function ($a, $b) {
    return $b['price'] <=> $a['price'];   // most expensive first
});

$labels = array_map(function ($p) {
    $label = strtoupper($p['name']);
    return "$label ({$p['stock']} left)";
}, $available);

print_r($labels);

Quand le corps est une seule expression, une fonction fléchée comme fn($p) => $p['price'] est plus courte et n'a pas besoin de use.

Callables : noms de fonctions, méthodes et strlen(...)

Un paramètre typé callable accepte plus que des closures. Une chaîne avec un nom de fonction, un tableau avec un objet et un nom de méthode, et un tableau avec un nom de classe et une méthode statique comptent tous. Depuis PHP 8.1, la syntaxe de callable de première classe strlen(...) transforme directement n'importe lequel en Closure.

<?php
class Formatter
{
    public function shout(string $s): string { return strtoupper($s) . '!'; }
    public static function whisper(string $s): string { return strtolower($s) . '...'; }
}

$words = ['Hello', 'World'];
$f = new Formatter();

print_r(array_map('strtoupper', $words));                   // function name
print_r(array_map([$f, 'shout'], $words));                  // object method
print_r(array_map([Formatter::class, 'whisper'], $words));  // static method

// PHP 8.1 first-class callable syntax
$len = strlen(...);
$shout = $f->shout(...);
$whisper = Formatter::whisper(...);
echo $len('closure'), ' ', $shout('hey'), ' ', $whisper('PSST'), "\n";

function apply(callable $fn, string $value): string
{
    return $fn($value);
}
echo apply('ucfirst', 'php'), "\n";
var_dump(is_callable('no_such_function'));

La forme (...) est vérifiée quand la ligne s'exécute : une faute de frappe lève une Error immédiatement. Une chaîne comme 'strtoupr' n'est qu'une chaîne jusqu'à ce que quelqu'un essaie de l'appeler.

Closures dans une classe : $this et static

Une closure créée dans une méthode a $this lié automatiquement, elle peut donc utiliser les propriétés de l'objet. Marquez-la static function quand elle n'a pas besoin de $this, ce qui l'empêche aussi de garder l'objet en vie.

<?php
class Cart
{
    private array $items = [];
    private float $taxRate = 0.2;

    public function add(string $name, float $price): void
    {
        $this->items[$name] = $price;
    }

    public function pricesWithTax(): array
    {
        // $this is available inside the closure
        return array_map(function (float $price): float {
            return round($price * (1 + $this->taxRate), 2);
        }, $this->items);
    }

    public function names(): array
    {
        return array_map(static function (string $name): string {
            return ucfirst($name);
        }, array_keys($this->items));
    }
}

$cart = new Cart();
$cart->add('book', 12.5);
$cart->add('pen', 1.99);
print_r($cart->pricesWithTax());
print_r($cart->names());

Oublier use

Le bug de closure le plus courant est d'utiliser une variable extérieure sans la lister dans use. Dans la closure, la variable n'existe pas :

$minAge = 18;
$adults = array_filter($people, function ($p) {
    return $p['age'] >= $minAge;   // $minAge is not in use (...)
});

PHP prints: Warning: Undefined variable $minAge

$minAge vaut null à l'intérieur, tout âge comparé >= null est vrai, et chaque personne passe le filtre. Sur un serveur qui masque les warnings, rien ne vous prévient. Ajoutez la variable à use :

<?php
$people = [['name' => 'Ada', 'age' => 36], ['name' => 'Tom', 'age' => 12]];
$minAge = 18;

$adults = array_filter($people, function ($p) use ($minAge) {
    return $p['age'] >= $minAge;
});
print_r(array_column($adults, 'name'));

// Or an arrow function, which captures $minAge automatically
$adults2 = array_filter($people, fn($p) => $p['age'] >= $minAge);
print_r(array_column($adults2, 'name'));