PHP Arrow Functions: Syntax fn() => und Beispiele

Eine Arrow Function ist eine kurze anonyme Funktion: fn($x) => $x * 2. Der Rumpf nach => ist ein einziger Ausdruck, dessen Wert zurückgegeben wird, und jede Variable aus dem umgebenden Code, die der Ausdruck verwendet, wird automatisch eingefangen, als Wert. Arrow Functions gibt es seit PHP 7.4, und sie werden meist als Callbacks verwendet.

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

Die Syntax

fn, die Parameterliste, =>, ein Ausdruck. Parametertypen, Standardwerte und ein Rückgabetyp funktionieren wie bei normalen Funktionen:

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

Es gibt kein Schlüsselwort return und keine geschweiften Klammern. Ein langer Ausdruck lässt sich zur besseren Lesbarkeit trotzdem über mehrere Zeilen verteilen.

Äußere Variablen werden als Wert eingefangen

Eine Arrow Function sieht jede Variable des Scopes, in dem sie erzeugt wird. Sie kopiert deren Werte in diesem Moment. Änderungen innen bleiben innen, und Änderungen außen nach dem Erzeugen der Funktion sieht sie nicht:

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

Das ist der Hauptunterschied zu function () use (&$count), das eine Variable per Referenz teilen kann. Eine Arrow Function kann einer äußeren Variable keinen neuen Wert zuweisen. Ein eingefangenes Objekt kann sie trotzdem ändern (die Kopie ist ein Verweis auf dasselbe Objekt), und ein per Referenz deklarierter Parameter funktioniert wie in jeder Funktion: fn(array &$list) => $list[] = 'x'.

Callbacks für array_map, array_filter und usort

Die meisten Array-Funktionen nehmen einen Callback, und dort sparen Arrow Functions am meisten Ballast. Vergleiche einen Filter, auf beide Arten geschrieben:

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

<=> liefert -1, 0 oder 1, genau das, was usort() will, also passt das Sortieren nach einem Feld in eine Zeile. Vertausche $a und $b, um absteigend zu sortieren.

Arrow Functions, die Arrow Functions zurückgeben

Zu den eingefangenen Variablen gehören die Parameter einer umschließenden Arrow Function, also kannst du sie verschachteln, um Funktionen aus anderen Werten zu bauen:

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

Beachte, dass array_filter() die ursprünglichen Schlüssel behält, und deshalb beginnt das Ergebnis bei Index 1.

fn vs function: wann du eine vollständige Closure brauchst

Arrow Functions kommen an ihre Grenze, wenn der Rumpf mehr als einen Ausdruck braucht oder eine äußere Variable ändern muss. Dann verwendest du eine anonyme Funktion:

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

Wenn sich eine Arrow Function eng anfühlt, sind es oft zwei Aufgaben in einer. Sie in einen Filter und eine Summe aufzuteilen, wie oben, hält jeden Callback bei einem einzigen Ausdruck.