PHP anonyme Funktionen und Closures: das Schlüsselwort use

Eine anonyme Funktion, auch Closure genannt, ist eine Funktion ohne Namen. Du schreibst function ($param) { ... } dort, wo ein Wert erwartet wird: Weise sie einer Variable zu, übergib sie an eine andere Funktion oder gib sie zurück. Mit use ($var) kann sie Variablen aus dem umgebenden Code mitnehmen.

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

Jede anonyme Funktion ist ein Objekt der eingebauten Klasse Closure, und deshalb lässt sie sich speichern, weitergeben und später mit $greet(...) aufrufen.

Das Schlüsselwort use fängt als Wert ein

Eine Closure sieht äußere Variablen nicht von selbst. use ($x) kopiert den Wert von $x in die Closure, und zwar in dem Moment, in dem die Closure erzeugt wird, nicht wenn sie läuft:

<?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 per Referenz: &$var

use (&$x) gibt der Closure die Variable selbst statt einer Kopie. Änderungen in der Closure sind draußen sichtbar, und Änderungen draußen sieht sie drinnen. So addiert ein Callback zu einer Summe oder führt einen Zähler.

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

Jeder Aufruf von makeCounter() erzeugt ein neues $count, und die zurückgegebene Closure hält es am Leben, nachdem die Funktion zurückgekehrt ist. Darauf bezieht sich das Wort „Closure“: Die Funktion schließt die Variablen ein, die sie braucht.

Eine Closure als Callback übergeben

Funktionen wie array_map(), array_filter(), usort() und array_walk() nehmen eine Funktion als Argument. Mit einer Closure schreibst du sie direkt an Ort und Stelle, mit so vielen Anweisungen, wie die Aufgabe braucht:

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

Wenn der Rumpf ein einziger Ausdruck ist, ist eine Arrow Function wie fn($p) => $p['price'] kürzer und braucht kein use.

Callables: Funktionsnamen, Methoden und strlen(...)

Ein Parameter vom Typ callable akzeptiert mehr als Closures. Ein String mit einem Funktionsnamen, ein Array mit einem Objekt und einem Methodennamen und ein Array mit einem Klassennamen und einem statischen Methodennamen zählen alle dazu. Seit PHP 8.1 macht die First-Class-Callable-Syntax strlen(...) aus jedem davon direkt eine 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'));

Die Form (...) wird beim Ausführen der Zeile geprüft: Ein Tippfehler wirft genau dort einen Error. Ein String wie 'strtoupr' ist nur ein String, bis jemand versucht, ihn aufzurufen.

Closures in einer Klasse: $this und static

Eine Closure, die in einer Methode erzeugt wird, hat $this automatisch gebunden und kann die Eigenschaften des Objekts verwenden. Markiere sie als static function, wenn sie $this nicht braucht; das verhindert auch, dass sie das Objekt am Leben hält.

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

use vergessen

Der häufigste Closure-Bug ist, eine äußere Variable zu verwenden, ohne sie in use aufzuführen. In der Closure existiert die Variable nicht:

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

PHP prints: Warning: Undefined variable $minAge

$minAge ist drinnen null, jedes Alter, das mit >= null verglichen wird, ist true, und jede Person besteht den Filter. Auf einem Server, der Warnungen versteckt, sagt dir nichts Bescheid. Füge die Variable zu use hinzu:

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