Arrow functions no PHP: sintaxe fn() => e exemplos

Uma arrow function é uma função anônima curta: fn($x) => $x * 2. O corpo depois do => é uma única expressão cujo valor é retornado, e qualquer variável do código em volta que a expressão usa é capturada automaticamente, por valor. Arrow functions existem desde o PHP 7.4 e são usadas principalmente 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));

A sintaxe

fn, a lista de parâmetros, =>, uma expressão. Tipos de parâmetro, valores padrão e um tipo de retorno funcionam como nas funções normais:

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

Não há palavra-chave return nem chaves. Uma expressão longa ainda pode ser quebrada em várias linhas para ficar legível.

Variáveis de fora são capturadas por valor

Uma arrow function enxerga todas as variáveis do escopo em que é criada. Ela copia os valores naquele momento. Mudanças feitas dentro ficam dentro, e mudanças feitas fora depois que a função foi criada não são vistas:

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

Essa é a principal diferença para function () use (&$count), que pode compartilhar uma variável por referência. Uma arrow function não consegue reatribuir uma variável de fora. Ela ainda pode alterar um objeto que capturou (a cópia é um handle para o mesmo objeto), e um parâmetro declarado por referência funciona como em qualquer função: fn(array &$list) => $list[] = 'x'.

Callbacks para array_map, array_filter e usort

A maioria das funções de array recebe um callback, e é aí que as arrow functions mais economizam ruído. Compare um filtro escrito dos dois jeitos:

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

<=> retorna -1, 0 ou 1, exatamente o que o usort() quer, então ordenar por um campo cabe numa linha. Troque $a e $b para ordenar em ordem decrescente.

Arrow functions que retornam arrow functions

As variáveis capturadas incluem os parâmetros de uma arrow function externa, então você pode aninhá-las para montar funções a partir de outros 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));

Repare que o array_filter() mantém as chaves originais, e é por isso que o resultado começa no índice 1.

fn ou function: quando você precisa de uma closure completa

Arrow functions deixam de servir quando o corpo precisa de mais de uma expressão ou precisa alterar uma variável de fora. Aí use uma função 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";

Quando uma arrow function parece apertada, muitas vezes é porque a tarefa são duas tarefas. Dividi-la num filtro e numa soma, como acima, mantém cada callback como uma única expressão.