Funkcje strzałkowe w PHP: składnia fn() => i przykłady

Funkcja strzałkowa to krótka funkcja anonimowa: fn($x) => $x * 2. Treść po => to jedno wyrażenie, którego wartość jest zwracana, a każda zmienna z otaczającego kodu, której wyrażenie używa, jest przechwytywana automatycznie, przez wartość. Funkcje strzałkowe istnieją od PHP 7.4 i służą głównie jako callbacki.

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

Składnia

fn, lista parametrów, =>, jedno wyrażenie. Typy parametrów, wartości domyślne i typ zwracany działają tak samo jak w zwykłych funkcjach:

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

Nie ma słowa kluczowego return ani nawiasów klamrowych. Długie wyrażenie nadal można dla czytelności rozbić na kilka linii.

Zmienne z zewnątrz są przechwytywane przez wartość

Funkcja strzałkowa widzi każdą zmienną zasięgu, w którym powstaje. Kopiuje ich wartości w tej chwili. Zmiany wewnątrz zostają wewnątrz, a zmiany na zewnątrz wykonane po utworzeniu funkcji nie są widoczne:

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

To główna różnica względem function () use (&$count), które może współdzielić zmienną przez referencję. Funkcja strzałkowa nie może przypisać nowej wartości do zmiennej z zewnątrz. Może jednak zmienić przechwycony obiekt (kopia to uchwyt do tego samego obiektu), a parametr zadeklarowany przez referencję działa jak w każdej funkcji: fn(array &$list) => $list[] = 'x'.

Callbacki dla array_map, array_filter i usort

Większość funkcji tablicowych przyjmuje callback i właśnie tam funkcje strzałkowe oszczędzają najwięcej szumu. Porównaj jeden filtr zapisany na oba sposoby:

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

<=> zwraca -1, 0 albo 1, czyli dokładnie to, czego chce usort(), więc sortowanie po polu mieści się w jednej linii. Zamień $a i $b, aby sortować malejąco.

Funkcje strzałkowe zwracające funkcje strzałkowe

Przechwytywane zmienne obejmują parametry otaczającej funkcji strzałkowej, więc możesz je zagnieżdżać, aby budować funkcje z innych wartości:

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

Zwróć uwagę, że array_filter() zachowuje oryginalne klucze, dlatego wynik zaczyna się od indeksu 1.

fn vs function: kiedy potrzebne jest pełne domknięcie

Funkcje strzałkowe przestają wystarczać, gdy treść potrzebuje więcej niż jednego wyrażenia albo musi zmienić zmienną z zewnątrz. Wtedy użyj funkcji anonimowej:

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

Gdy funkcji strzałkowej robi się ciasno, często oznacza to, że zadanie to tak naprawdę dwa zadania. Podzielenie go na filtr i sumę, jak wyżej, sprawia, że każdy callback pozostaje jednym wyrażeniem.