mitmario.dev

Anonyme Funktionen

PHP Sandbox 3 Min Lesezeit 5 BeispieleLektion 6 von 8

usort braucht eine Funktion, die zwei Einträge vergleicht, und die brauchst du nur an dieser einen Stelle. Ihr dafür einen Namen zu geben und sie irgendwo oben in die Datei zu stellen, wäre Aufwand ohne Gewinn. Eine anonyme Funktion steht dort, wo sie gebraucht wird. Einen Namen braucht sie nicht.

Eine Funktion, die keinen Namen hat

Eine Funktion ohne Namen
<?php

declare(strict_types=1);

// Mit Namen, wie bisher:
function verdopple(int $z): int
{
    return $z * 2;
}

// Ohne Namen, dafuer in einer Variablen:
$verdreifache = function (int $z): int {
    return $z * 3;
};

echo verdopple(7), "\n";
echo $verdreifache(7), "\n";

// Was steckt in der Variablen?
echo get_debug_type($verdreifache), "\n";

Nach function folgt bei einer anonymen Funktion direkt die Klammer. Der Name fehlt. Dafür steht am Ende ein Semikolon, denn das Ganze ist eine Zuweisung wie jede andere.

In der Variablen liegt ein Objekt vom Typ Closure. Was ein Objekt genau ist, kommt in der nächsten Lektion. Aufrufen kannst du es wie eine Funktion, mit den Klammern hinter dem Variablennamen.

Wichtiger als die Variable ist, dass sich so eine Funktion übergeben lässt, an usort, an array_map, an array_filter. Diese Funktionen interessiert kein Name. Sie wollen wissen, was zu tun ist.

Auch hier gilt der Gültigkeitsbereich

Auch hier sieht der Rumpf nichts von draußen
<?php

declare(strict_types=1);

$grenze = 200;

$obst = [
    ["name" => "Apfel", "preis" => 190],
    ["name" => "Kirsche", "preis" => 340],
    ["name" => "Zitrone", "preis" => 90],
];

// Ohne use kennt der Rumpf $grenze nicht:
$ohne = array_filter($obst, function (array $o): bool {
    return $o["preis"] > $grenze;
});
echo "ohne use: ", count($ohne), " übrig\n";

// Mit use kommt der Wert herein:
$mit = array_filter($obst, function (array $o) use ($grenze): bool {
    return $o["preis"] > $grenze;
});
echo "mit use: ", count($mit), " übrig\n";

ohne use: 3 übrig in der ersten Zeile heißt, dass nichts herausgefallen ist. Dabei liegt die Grenze bei 200, und zwei Preise sind darunter.

Der Grund ist derselbe wie bei einer Funktion mit Namen. Der Rumpf der anonymen Funktion sieht $grenze nicht, obwohl die Variable weiter oben in derselben Datei steht. Er bekommt null, und jeder Preis ist größer als nichts. Auf dem Fehlerkanal stehen dazu drei Warnungen, eine je Durchgang.

use ($grenze) hinter der Parameterliste holt den Wert herein. Damit stimmt die zweite Zeile. Mehrere Werte stehen dort mit Komma getrennt.

Die kurze Form spart sich das

Die kurze Form holt sich die Umgebung selbst
<?php

declare(strict_types=1);

$grenze = 200;

$obst = [
    ["name" => "Apfel", "preis" => 190],
    ["name" => "Kirsche", "preis" => 340],
    ["name" => "Zitrone", "preis" => 90],
];

// Lange Form:
$lang = array_filter($obst, function (array $o) use ($grenze): bool {
    return $o["preis"] > $grenze;
});

// Kurze Form, holt sich $grenze von selbst:
$kurz = array_filter($obst, fn(array $o): bool => $o["preis"] > $grenze);

echo count($lang), " und ", count($kurz), "\n";

$namen = array_map(fn(array $o): string => $o["name"], $kurz);
echo implode(", ", $namen), "\n";

fn statt function, ein Doppelpfeil statt der geschweiften Klammern, und kein use. Eine Pfeilfunktion (englisch arrow function) holt sich alles, was sie braucht, von selbst aus ihrer Umgebung. Deshalb liefern beide Fassungen im Beispiel dasselbe Ergebnis.

Dafür passt in eine Pfeilfunktion nur ein einziger Ausdruck. Kein Semikolon, keine zweite Anweisung, kein if mit geschweiften Klammern. Was hinter dem Doppelpfeil steht, ist von selbst der Rückgabewert, ein return steht dort nicht.

Womit die Funktion rechnet, steht früh fest

Der Wert wird beim Aufschreiben genommen
<?php

declare(strict_types=1);

$n = 1;

$mitUse = function () use ($n): int {
    return $n;
};

$pfeil = fn(): int => $n;

// Beide werden erst jetzt aufgerufen, nach der Aenderung:
$n = 2;

echo $mitUse(), "\n";
echo $pfeil(), "\n";
echo $n, "\n";

Beide Funktionen geben 1 zurück, obwohl $n vor dem Aufruf auf 2 gesetzt wurde.

use ($n) nimmt eine Kopie. Die entsteht in dem Moment, in dem die anonyme Funktion aufgeschrieben wird, und nicht erst, wenn sie läuft. Bei fn ist es genauso. Meistens will man das so, denn die Funktion soll mit dem Wert rechnen, der galt, als sie entstanden ist.

Nach Aufzeichnen siehst du im Reiter Debug beide Werte, an der echo-Zeile draußen n=2 und an der return-Zeile in $mitUse n=1. Das sind zwei Variablen mit demselben Namen und verschiedenen Werten, das Original und die Kopie. Die Pfeilfunktion taucht in der Liste nicht auf, weil sie keine Anweisung hat, nur einen Ausdruck.

Es gäbe auch use (&$n) mit dem kaufmännischen Und. Dann arbeitet die Funktion mit dem Original. Wie das & vor einem Parameter steht es hier nur, damit du es erkennst, wenn es dir begegnet.

Eine Regel mit Stellschraube

Sortieren mit eigener Regel
<?php

declare(strict_types=1);

$richtung = -1;

$obst = [
    ["name" => "Apfel", "preis" => 190],
    ["name" => "Kirsche", "preis" => 340],
    ["name" => "Zitrone", "preis" => 90],
];

usort($obst, function (array $a, array $b) use ($richtung): int {
    return $richtung * ($a["preis"] <=> $b["preis"]);
});

foreach ($obst as $frucht) {
    echo $frucht["name"], ": ", $frucht["preis"], " Cent\n";
}

usort will eine Funktion, die zwei Einträge vergleicht und eine Zahl zurückgibt, negativ, wenn der erste vorne stehen soll, positiv, wenn der zweite vorne stehen soll, und 0 bei Gleichstand. Diese Zahl liefert der Raumschiff-Operator <=> aus Lektion 5.5.

Hier steht die lange Form, damit du das use einmal an einem echten Fall siehst. Sonst nehme ich fn, wenn es in eine Zeile passt, und die lange Form, sobald die Funktion mehrere Schritte braucht. Mit -1 dreht sich das Ergebnis um, aus aufsteigend wird absteigend. Eine zweite Vergleichsfunktion braucht es dafür nicht.

In der Aufgabe stecken beide Formen in einem Programm, die lange zum Sortieren und fn zum Sieben.

Zum Mitnehmen

usort, array_map und array_filter bekommen ihre Regel als anonyme Funktion, direkt im Aufruf und ohne Namen. Die lange Form holt Werte von außen mit use herein, die Pfeilfunktion mit fn holt sie sich selbst, beide als Kopie zum Zeitpunkt des Aufschreibens.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 5 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.