Mit PHP 7.4 wurden Arrow Functions eingeführt, eine kompaktere Schreibweise für anonyme Funktionen. Arrow Functions verwenden das Schlüsselwort fn, haben ein implizites return und greifen automatisch auf Variablen aus dem äußeren Scope zu, ohne das use-Keyword zu benötigen. Besonders in Kombination mit Array-Funktionen wie array_map(), array_filter() und usort() machen sie den Code deutlich lesbarer. In diesem Tutorial lernst du die Syntax, den Unterschied zu klassischen Closures und die Einschränkungen von Arrow Functions.
Zunächst wird erklärt, was Arrow Functions sind und wie ihre Syntax aufgebaut ist. Anschließend folgen Praxisbeispiele mit Array-Funktionen und ein direkter Vergleich mit klassischen Closures.
Was sind Arrow Functions?
Arrow Functions sind eine Kurzschreibweise für anonyme Funktionen in PHP. Sie wurden entwickelt, um kurze Callback-Funktionen kompakter und lesbarer zu machen. Der Name leitet sich vom Pfeil-Operator (=>) ab, der den Funktionskörper einleitet. Im Gegensatz zu klassischen Closures müssen Variablen aus dem umgebenden Scope nicht explizit mit use importiert werden. Sie stehen automatisch zur Verfügung.
Syntax der Arrow Function
Eine Arrow Function beginnt mit fn, gefolgt von der Parameterliste und dem Pfeil-Operator. Nach dem Pfeil steht ein einzelner Ausdruck, dessen Wert automatisch zurückgegeben wird.
<?php
$verdoppeln = fn(int $x): int => $x * 2;
echo $verdoppeln(5);
/* Ausgabe: 10 */
Der Rückgabewert des Ausdrucks $x * 2 wird implizit zurückgegeben. Ein explizites return ist weder nötig noch erlaubt. Typdeklarationen für Parameter und Rückgabewert können wie bei normalen Funktionen angegeben werden.
Arrow Functions können auch mehrere Parameter verwenden:
<?php
$addieren = fn(int $a, int $b): int => $a + $b;
echo $addieren(3, 7);
/* Ausgabe: 10 */
Automatischer Zugriff auf den äußeren Scope
Der größte Unterschied zu klassischen Closures ist der automatische Scope-Zugriff. Arrow Functions übernehmen alle Variablen aus dem umgebenden Scope automatisch per Wert (by Value), ohne dass ein use-Keyword benötigt wird.
<?php
$mwst = 0.19;
$bruttoPreis = fn(float $netto): float => $netto * (1 + $mwst);
echo $bruttoPreis(100);
/* Ausgabe: 119 */
/* Kein use-Keyword noetig.
Die Variable $mwst wird automatisch
aus dem aeusseren Scope uebernommen. */
Die Übernahme geschieht immer by Value, also als Kopie. Die Arrow Function kann die Original-Variable im äußeren Scope nicht verändern. Ein use by Reference wie bei klassischen Closures ist nicht möglich.
Arrow Functions in Array-Funktionen
Der häufigste Einsatzbereich für Arrow Functions sind Callbacks in Array-Funktionen. Hier zeigen sie ihren größten Vorteil: kürzerer, besser lesbarer Code.
Einsatz in array_map
<?php
$zahlen = [1, 2, 3, 4, 5];
$verdoppelt = array_map(fn($n) => $n * 2, $zahlen);
/* [2, 4, 6, 8, 10] */
Einsatz in array_filter
<?php
$zahlen = [1, 2, 3, 4, 5, 6, 7, 8];
$gerade = array_filter($zahlen, fn($n) => $n % 2 === 0);
/* [2, 4, 6, 8] */
Einsatz in usort
<?php
$namen = ['Anna', 'Bo', 'Christine', 'Dan'];
usort($namen, fn($a, $b) => strlen($a) - strlen($b));
/* ['Bo', 'Dan', 'Anna', 'Christine'] */
In allen drei Fällen ist die Arrow Function deutlich kompakter als die Closure-Variante mit function, use und return. Gerade bei einfachen Transformationen und Filteroperationen erhöht das die Lesbarkeit erheblich. Der Code wird kürzer und der Fokus liegt auf der eigentlichen Logik statt auf syntaktischem Overhead.
Arrow Functions können auch verschachtelt in Array-Funktionen eingesetzt werden. Ein typisches Beispiel ist die Kombination von array_map() und array_filter() in einer Verarbeitungskette:
<?php
$produkte = [
['name' => 'Tastatur', 'preis' => 49.90],
['name' => 'Maus', 'preis' => 29.90],
['name' => 'Monitor', 'preis' => 299.00],
['name' => 'Kabel', 'preis' => 4.99],
];
/* Nur Produkte ueber 20 EUR, dann Preise extrahieren */
$preise = array_map(
fn($p) => $p['preis'],
array_filter($produkte, fn($p) => $p['preis'] > 20)
);
/* [49.90, 29.90, 299.00] */
Durch Arrow Functions bleibt die Verarbeitungskette kompakt und gut lesbar, selbst wenn mehrere Array-Funktionen kombiniert werden.
Unterschied zwischen Arrow Functions und Closures
Arrow Functions und klassische Closures sind eng verwandt, unterscheiden sich aber in mehreren Punkten.
<?php
$schwellwert = 10;
/* Klassische Closure mit use */
$filter1 = function(int $wert) use ($schwellwert): bool {
return $wert > $schwellwert;
};
/* Arrow Function (kompakter) */
$filter2 = fn(int $wert): bool => $wert > $schwellwert;
/* Beide liefern dasselbe Ergebnis */
Die wesentlichen Unterschiede sind:
- Scope-Zugriff: Closures benötigen
use, Arrow Functions importieren automatisch. - Funktionskörper: Closures erlauben mehrzeilige Blöcke, Arrow Functions nur einen einzelnen Ausdruck.
- Return: Closures benötigen ein explizites
return, Arrow Functions geben den Ausdruck implizit zurück. - By Reference: Closures unterstützen
use (&$var), Arrow Functions nicht. - Äußeren Scope verändern: Mit Closures und
use by Reference möglich, mit Arrow Functions nicht. - Semikolon: Bei Closures ist das abschließende Semikolon nach der schließenden Klammer Pflicht, bei Arrow Functions ebenfalls.
Eine wichtige Gemeinsamkeit: Beide sind Instanzen der Closure-Klasse. Der Ausdruck $fn instanceof \Closure gibt sowohl für klassische Closures als auch für Arrow Functions true zurück. Für den aufrufenden Code sind sie identisch, nur die Syntax und das Scope-Verhalten unterscheiden sich.
Einschränkungen von Arrow Functions
Trotz ihrer Vorteile haben Arrow Functions klare Grenzen, die ihren Einsatzbereich definieren. Es ist wichtig, diese Einschränkungen zu kennen, um die richtige Entscheidung zwischen Arrow Function und klassischer Closure zu treffen.
Nur ein Ausdruck erlaubt
Arrow Functions können nur einen einzelnen Ausdruck enthalten. Mehrere Anweisungen, Schleifen oder bedingte Logik mit if/else sind nicht möglich. Für solche Fälle muss eine klassische Closure oder eine benannte Funktion verwendet werden.
Kein use by Reference
Da Arrow Functions Variablen immer by Value übernehmen, können sie Variablen im äußeren Scope nicht verändern. Wenn ein Zähler oder Akkumulator benötigt wird, muss eine Closure mit use (&$var) verwendet werden.
Keine mehrzeiligen Blöcke
Anders als in JavaScript, wo Arrow Functions mit geschweiften Klammern mehrzeilige Blöcke erlauben, ist das in PHP nicht möglich. PHP-Arrow-Functions sind strikt auf einen Ausdruck beschränkt. Verschachtelte Arrow Functions sind zwar syntaktisch möglich, verschlechtern aber die Lesbarkeit und sollten vermieden werden.
Wann Arrow Functions verwenden?
Arrow Functions eignen sich immer dann, wenn eine kurze, einzeilige Callback-Funktion benötigt wird. Typische Einsatzfälle sind:
- Transformationen mit
array_map() - Filterung mit
array_filter() - Sortierung mit
usort() - Einfache Berechnungen und Zuordnungen
- Kurzschreibweisen für Validierungsregeln
Wenn der Callback mehr als eine Zeile Code benötigt, die Variable im äußeren Scope verändert werden muss oder use by Reference erforderlich ist, bleibt die klassische Closure die richtige Wahl.
In Frameworks wie Laravel werden Arrow Functions häufig für Route-Definitionen, Collection-Methoden und Validierungsregeln eingesetzt. Sie haben sich als Standard für kurze Callbacks in der gesamten PHP-Community etabliert.
Arrow Functions können übrigens auch ohne Parameter definiert werden. In diesem Fall steht eine leere Parameterliste vor dem Pfeil:
<?php
$aktuellesDatum = fn() => date('Y-m-d');
echo $aktuellesDatum();
/* Ausgabe: 2026-03-06 */
Auch Standardwerte für Parameter sind möglich, genau wie bei normalen Funktionen und Closures. Nullable Types und Union Types werden ebenfalls unterstützt. Damit bieten Arrow Functions dieselbe Typsicherheit wie klassische Funktionsdefinitionen, nur in kompakterer Form.
flowchart TD
A["Klassische Closure"] --> B["function($x) use ($var) { return $x + $var; }"]
C["Arrow Function"] --> D["fn($x) => $x + $var"]
B --> E["Gleicher Rueckgabewert"]
D --> E
style C fill:#9f9,stroke:#333
Typische Fehler und Stolperfallen
Beim Einsatz von Arrow Functions treten einige wiederkehrende Fehler auf:
- Der Versuch, mehrere Anweisungen in einer Arrow Function unterzubringen, führt zu einem Syntax Error. Für mehrzeilige Logik muss eine Closure verwendet werden.
- Variablen werden immer by Value übernommen. Der Versuch, eine äußere Variable zu verändern, zeigt keine Wirkung im äußeren Scope.
- Arrow Functions sind erst ab PHP 7.4 verfügbar. In älteren Versionen führt die
fn-Syntax zu einem Syntax Error. - Die Verwechslung mit JavaScript-Arrow-Functions ist verbreitet. In JavaScript können Arrow Functions mehrzeilige Blöcke mit geschweiften Klammern enthalten, in PHP nicht.
- Verschachtelte Arrow Functions sind möglich, machen den Code aber schwer lesbar. In solchen Fällen sind benannte Funktionen oder Closures vorzuziehen.
Fazit
Arrow Functions sind eine willkommene Ergänzung zu PHP seit Version 7.4. Sie machen kurze Callbacks kompakter und lesbarer, indem sie auf das use-Keyword, das explizite return und den umfangreichen Funktionskörper verzichten. In Array-Funktionen wie array_map(), array_filter() und usort() spielen sie ihre Stärke voll aus. Für komplexere Logik, mehrzeilige Blöcke oder den Zugriff per Referenz bleiben klassische Closures die richtige Wahl. Beide Varianten ergänzen sich und gehören zum Standardwerkzeug moderner PHP-Entwicklung. Das Verständnis beider Schreibweisen ist eine Voraussetzung für die Arbeit mit modernen Frameworks und Bibliotheken, die Arrow Functions und Closures intensiv einsetzen. Im Zweifel gilt die Faustregel: Passt die Logik in eine Zeile, verwende eine Arrow Function. Benötigst du mehr als eine Zeile oder musst Variablen per Referenz übergeben, verwende eine klassische Closure. Wer beide Schreibweisen sicher beherrscht, kann in jeder Situation die passende Variante wählen.
