Anonyme Funktionen (Lambdas) in PHP

Thema in Kurzform

• Eine anonyme Funktion (auch Lambda genannt) hat keinen Namen.
• Anonyme Funktionen können Variablen zugewiesen werden:
• Anonyme Funktionen können als Argumente anderen Funktionen übergeben werden (=Callback):

Inhaltsverzeichnis

1. Was ist eine anonyme Funktion überhaupt?
2. Eine anonyme Funktion einer Variablen zuweisen
3. Anonyme Funktionen als Callback einsetzen
4. Übungen

Was ist eine anonyme Funktion überhaupt?

Anonyme Funktionen werden auch Lambda-Funktionen genannt und stehen in PHP seit Version 5.3 zur Verfügung.

Bevor wir uns die erste anonyme Funktion ansehen, betrachten wir noch einmal eine reguläre Funktionsdefinition:

function meineFunktion(){
    // Code...
}

Eine reguläre Funktion wird mit dem Schlüsselwort function und einem Namen bzw. Bezeichner (meineFunktion) definiert. Aufgerufen wird die Funktion über den Bezeichner:

meineFunktion();

Jetzt ein Beispiel für eine anonyme Funktion:

function($var){
    // I'm so anonymous
};

Uns fallen gleich zwei große Unterschiede zu regulären Funktionen auf:

• Eine anonyme Funktion hat keinen Namen
• Anonyme Funktionen schließen mit einem Semikolon ; am Ende ab.

Da eine anonyme Funktion keinen Namen hat und somit nicht an einen Bezeichner gebunden ist, können wir sie auch nicht ohne Weiteres ansprechen. Eine anonyme Funktion wie oben könnte also niemals aufgerufen werden.

Wie setze ich eine anonyme Funktion ein?

Der Einsatz von anonymen Funktionen ist speziell. Wir können sie einsetzen, indem wir sie

• einer Variablen zuweisen oder
• einer anderen Funktion als Argument übergeben (Callback).

Sehen wir uns diese beiden Möglichkeiten nun genauer an.

Eine anonyme Funktion einer Variablen zuweisen

Wenn wir eine anonyme Funktion erstellen, können wir sie einer Variablen zuweisen:

$result = function($x, $y){
    return $x + $y;
};

Jetzt kann die Funktion über die Variable $result aufgerufen werden:

echo $result(10, 5); // 15

Ein Array von Funktionen

Wenn wir einer Variablen eine Funktion zuweisen können, könnten wir ihr dann nicht auch ein ganzes Array aus Funktionen zuweisen? So ist es 😉

$meinArray = array(
    function () {
        echo "Funktion Nr. 1";
    },
    function () {
        echo "Funktion Nr. 2";
    },
    function () {
        echo "Funktion Nr. 3";
    }
);

Das Array wird wie gewohnt über die Index-Nummern angesteuert:

$meinArray[1](); // Funktion Nr. 2

Anonyme Funktionen als Callback einsetzen

Der wahre Nutzen von anonymen Funktionen kommt beim Einsatz als Callback zum Tragen.

Was ist eine Callback-Funktion?

• Eine Callback-Funktion ist eine Funktion, die einer anderen Funktion als Parameter übergeben wird.

In PHP gibt es einige vordefinierte Funktionen, die callbacks ermöglichen. Als Beispiel sehen wir uns array_map() an.

Mit array_map() wird ein komplettes Array transformiert und als neues Array zurückliefern. Die Funktion benötigt zwei Parameter: Ein Ausgangs-Array und eine Callback-Funktion.

array_map() iteriert dann durch alle Elemente des Arrays und wendet auf jedem Element die Callback-Funktion an.

Das mag wie höhere Computerwissenschaft klingen, ist in Wirklichkeit aber nur Gewöhnungssache. Hier ein konkretes Beispiel:

$array = array(1, 2, 3, 4, 5);

// anonyme Callback-Funktion:
$multiplicate = function ($var){
    return $var * 2;
};

$arrayNeu = array_map($multiplicate, $array);

print_r($arrayNeu);

// Output:
// Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10 )

Wir erstellen in diesem Beispiel eine anonyme Funktion mit einem return-Statement und weisen sie der Variablen $multiplicate zu. $multiplicate wird dann array_map() als erstes Argument übergeben. Das ist der Callback.

array_map() sendet jetzt jedes Element des Arrays an die Callback-Funktion und liefert den mit 2 multiplizierten Wert zurück. So entsteht ein neues Array, das in $arrayNeu2 gespeichert wird.

Anonyme Funktionen ohne Variable

Achtung, jetzt wird's heiß!

Anonyme Funktionen können nämlich sogar ohne Variablen-Zuweisung verwendet werden. Wie soll das gehen, fragst du dich vielleicht, da wir die Funktion doch "irgendwie" ansprechen müssen.

Die Lösung: Wir übergeben array_map() als erstes Argument keine Variable, sondern einfach direkt den gesamten Code der anonymen Funktion:

$array = array(1, 2, 3, 4, 5);

$arrayNeu = array_map(function ($var){ return $var * 2;}, $array);

Mit diesem Code erfassen wir Sinn und Nutzen anonymer Funktionen vollständig: Wir können eine einmalige Aufgabe "an Ort und Stelle" erledigen, ohne sie ganz woanders im Code erst noch definieren zu müssen. Damit könnte man anonyme Funktionen auch als "Einweg-Funktionen" (throw away functions) bezeichnen, die wir nur einmal verwenden können.

Außerdem können wir auf diese Weise eleganten und (nach der Gewöhnungsphase) übersichtlicheren Code schreiben.

Übungen

$xxx = function myFunction(){
    echo "Hallo PHP";
}

$xxx = function(){
    echo "Hallo PHP";
}

// unwichtiger Code ...
function($x){
    echo "Hallo PHP";
}
// unwichtiger Code ...

$griechischeHelden = array("helena", "achilles", "hektor");

$griechischeHelden = array("helena", "achilles", "hektor");
print_r(array_map(function($held){return ucfirst($held);}, $griechischeHelden));