Anonyme Funktionen
Anonyme Funktionen, auch bekannt als Closures,
ermöglichen es, Funktionen ohne Funktionsnamen zu schreiben. Sie sind am
nützlichsten als Werte von callable-Parametern, haben aber
noch viele andere Verwendungsmöglichkeiten.
Anonyme Funktionen werden unter Verwendung der Klasse
Closure
implementiert.
Beispiel #1 Beispiel für eine anonyme Funktion
<?php
echo preg_replace_callback('~-([a-z])~', function ($match) {
return strtoupper($match[1]);
}, 'hallo-welt');
// gibt halloWelt aus
?>
Closures können auch als Werte von Variablen verwendet werden; PHP
konvertiert solche Ausdrücke automatisch in Instanzen der internen Klasse
Closure. Die Zuweisung einer Closure an eine
Variable verwendet die selbe Syntax wie andere Zuweisungen, einschließlich
des abschließenden Semikolons:
Beispiel #2 Beispiel für die Zuweisung einer anonymen Funktion
<?php
$greet = function($name) {
printf("Hallo %s\r\n", $name);
};
$greet('Welt');
$greet('PHP');
?>
Closures können auch Variablen aus dem Eltern-Gültigkeitsbereich erben.
Jede solche Variable muss an das use-Sprachkonstrukt
übergeben werden. Von PHP 7.1 an dürfen diese Variablen keine
superglobals, $this oder Variablen mit dem
gleichen Name wie ein Parameter sein. Die Deklaration des Rückgabetyps der
Funktion muss nach der use-Klausel
erfolgen.
Beispiel #3 Erben von Variablen aus dem Eltern-Gültigkeitsbereich
<?php
$message = 'hallo';
// Kein "use"
$example = function () {
var_dump($message);
};
$example();
// $message vererben
$example = function () use ($message) {
var_dump($message);
};
$example();
// Der Wert einer geerbten Variable ist der Wert zum Zeitpunkt
// der Funktionsdefinition, nicht des Funktionsaufrufs
$message = 'welt';
$example();
// $message wiederherstellen
$message = 'hallo';
// Vererben per Referenz
$example = function () use (&$message) {
var_dump($message);
};
$example();
// Der geänderte Wert im Eltern-Gültigkeitsbereich
// wird in der aufgerufenen Funktion übernommen
$message = 'welt';
$example();
// Closures können auch reguläre Argumente akzeptieren
$example = function ($arg) use ($message) {
var_dump($arg . ' ' . $message);
};
$example("hallo");
// Die Deklaration des Rückgabetyps erfolgt nach der use-Klausel
$example = function () use ($message): string {
return "hallo $message";
};
var_dump($example());
?>
Das oben gezeigte Beispiel erzeugt
eine ähnliche Ausgabe wie:
Notice: Undefined variable: message in /example.php on line 10
NULL
string(5) "hallo"
string(5) "hallo"
string(5) "hallo"
string(4) "welt"
string(10) "hallo welt"
string(10) "hallo welt"
Seit PHP 8.0.0 darf die Liste der geerbten Variablen ein nachgestelltes
Komma enthalten, das ignoriert wird.
Das Erben von Variablen aus dem Eltern-Gültigkeitsbereich ist
nicht das gleiche wie die Verwendung von globalen
Variablen. Globale Variablen existieren im globalen Gültigkeitsbereich,
der immer der gleiche ist, unabhängig davon, welche Funktion ausgeführt
wird. Der Eltern-Gültigkeitsbereich einer Closure ist die Funktion, in der
die Closure deklariert wurde (nicht notwendigerweise die Funktion, aus der
sie aufgerufen wurde). Betrachten Sie das folgende Beispiel:
Beispiel #4 Closures und Gültigkeitsbereiche
<?php
// Ein einfacher Einkaufswagen, der eine Liste von hinzugefügten Produkten
// und die Menge jedes Produkts enthält. Er enthält eine Methode, die den
// Gesamtpreis der Waren im Einkaufswagen unter Verwendung einer Closure
// als Callback berechnet.
class Einkaufswagen
{
const PREIS_BUTTER = 1.00;
const PREIS_MILCH = 3.00;
const PREIS_EIER = 6.95;
protected $produkte = array();
public function addiere($produkt, $menge)
{
$this->produkte[$produkt] = $menge;
}
public function ermittleMenge($produkt)
{
return isset($this->produkte[$produkt]) ? $this->produkte[$produkt] :
FALSE;
}
public function ermittleGesamt($steuer)
{
$gesamt = 0.00;
$callback =
function ($menge, $produkt) use ($steuer, &$gesamt)
{
$preisProStueck = constant(__CLASS__ . "::PREIS_" .
strtoupper($produkt));
$gesamt += ($preisProStueck * $menge) * ($steuer + 1.0);
};
array_walk($this->produkte, $callback);
return round($gesamt, 2);
}
}
$mein_einkaufswagen = new Einkaufswagen;
// Lege ein paar Waren in den Einkaufskorb
$mein_einkaufswagen->addiere('butter', 1);
$mein_einkaufswagen->addiere('milch', 3);
$mein_einkaufswagen->addiere('eier', 6);
// Gib die Gesamtsumme mit einer Mehrwertsteuer von 5% aus
print $mein_einkaufswagen->ermittleGesamt(0.05) . "\n";
// Das Ergebnis ist 54.29
?>
Beispiel #5 Automatisches Binden von $this
<?php
class Test
{
public function testing()
{
return function() {
var_dump($this);
};
}
}
$object = new Test;
$function = $object->testing();
$function();
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Wird eine anonyme Funktion im Kontext einer Klasse deklariert, so wird
diese Klasse automatisch an jene gebunden, was $this
innerhalb des Geltungsbereichs verfügbar macht. Ist diese automatische
Bindung der aktuellen Klasse nicht erwünscht, dann können stattdessen
statische anonyme Funktionen
verwendet werden.
Statische anonyme Funktionen
Anonyme Funktionen können statisch deklariert werden. Dies verhindert,
dass die aktuelle Klasse automatisch an sie gebunden wird. Objekte können
zur Laufzeit ebenfalls nicht an sie gebunden werden.
Beispiel #6 Versuch der Verwendung von $this innerhalb einer statischen anonymen Funktion
<?php
class Foo
{
function __construct()
{
$func = static function() {
var_dump($this);
};
$func();
}
};
new Foo();
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Notice: Undefined variable: this in %s on line %d
NULL
Beispiel #7 Versuch, ein Objekt an eine statische anonyme Funktion zu binden
<?php
$func = static function() {
// function body
};
$func = $func->bindTo(new stdClass);
$func();
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Warning: Cannot bind an instance to a static closure in %s on line %d
