Funciones flecha en PHP: sintaxis fn() => y ejemplos

Una función flecha es una función anónima corta: fn($x) => $x * 2. El cuerpo tras => es una sola expresión cuyo valor se devuelve, y cualquier variable del código que la rodea que use la expresión se captura automáticamente, por valor. Las funciones flecha existen desde PHP 7.4 y se usan sobre todo como 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 sintaxis

fn, la lista de parámetros, => y una expresión. Los tipos de los parámetros, los valores por defecto y el tipo de retorno funcionan igual que en las funciones 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";

No hay palabra clave return ni llaves. Una expresión larga se puede repartir en varias líneas para que se lea mejor.

Las variables de fuera se capturan por valor

Una función flecha ve todas las variables del ámbito donde se crea. Copia sus valores en ese momento. Los cambios hechos dentro se quedan dentro, y los cambios hechos fuera después de crear la función no se ven:

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

Esta es la principal diferencia con function () use (&$count), que puede compartir una variable por referencia. Una función flecha no puede reasignar una variable de fuera. Sí puede cambiar un objeto que haya capturado (la copia es un manejador del mismo objeto), y un parámetro declarado por referencia funciona como en cualquier función: fn(array &$list) => $list[] = 'x'.

Callbacks para array_map, array_filter y usort

La mayoría de las funciones de arrays reciben un callback, y ahí es donde las funciones flecha ahorran más ruido. Compara un filtro escrito de las dos formas:

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

<=> devuelve -1, 0 o 1, justo lo que quiere usort(), así que ordenar por un campo cabe en una línea. Intercambia $a y $b para ordenar de forma descendente.

Funciones flecha que devuelven funciones flecha

Las variables capturadas incluyen los parámetros de una función flecha exterior, así que puedes anidarlas para construir funciones a partir de otros valores:

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

Fíjate en que array_filter() conserva las claves originales, y por eso el resultado empieza en el índice 1.

fn vs function: cuándo necesitas un closure completo

Las funciones flecha dejan de servir cuando el cuerpo necesita más de una expresión o debe cambiar una variable de fuera. Entonces usa una función anónima:

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

Cuando una función flecha se queda corta, a menudo significa que el trabajo son dos trabajos. Dividirlo en un filtro y una suma, como arriba, mantiene cada callback en una sola expresión.