Pfeilfunktionen

Pfeilfunktionen wurden in PHP 7.4 als prägnantere Syntax für anonyme Funktionen eingeführt.

Sowohl anonyme Funktionen wie Pfeilfunktionen sind unter Verwendung der Closure-Klasse implementiert.

Pfeilfunktionen haben die grundsätzliche Form fn (argument_list) => expr.

Pfeilfunktionen unterstützen dieselben Features wie anonyme Funktionen, außer, dass die Verwendung von Variablen des Elterngültigkeitsbereichs immer automatisch erfolgt.

Wenn eine Variable, die im Ausdruck verwendet wird, im Elterngültigkeitsbereich definiert ist, wird sie implizit per Wertübergabe gebunden. Im folgenden Beispiel verhalten sich die Funktionen $fn1 und $fn2 auf die gleiche Weise.

Beispiel #1 Pfeilfunktionen binden Variablen automatisch per Wertübergabe

<?php

$y 
1;
 
$fn1 fn($x) => $x $y;
// gleichwertig zur Verwendung von $y per Wertübergabe:
$fn2 = function ($x) use ($y) {
    return 
$x $y;
};

var_export($fn1(3));
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

4

Die funktioniert ebenfalls, wenn Pfeilfunktionen verschachtelt werden:

Beispiel #2 Pfeilfunktionen binden Variablen automatisch per Wertübergabe, selbst wenn sie verschachtelt sind

<?php

$z 
1;
$fn fn($x) => fn($y) => $x $y $z;
// gibt 51 aus
var_export($fn(5)(10));
?>

Ähnlich wie bei anonymen Funktion, erlaubt die Pfeilfunktionssyntax beliebige Funktionssignaturen, einschließlich Parameter- und Rückgabetypen, Defaultwerten, variadischen Parametern, sowie Referenzübergabe und -rückgabe. Alle folgenden sind gültige Beispiele von Pfeilfunktionen:

Beispiel #3 Beispiele von Pfeilfunktionen

<?php

fn
(array $x) => $x;
static 
fn(): int => $x;
fn($x 42) => $x;
fn(&$x) => $x;
fn&($x) => $x;
fn($x, ...$rest) => $rest;

?>

Pfeilfunktionen verwenden Wertübergabe-Bindung. Dies entspricht in etwa der Verwendung von use($x) für jede Variable $x, die in der Pfeilfunktion verwendet wird. Wertübergabe-Bindung bedeutet, dass es nicht möglich ist Werte aus dem äußeren Geltungsbereich zu ändern. Anonyme Funktionen können statt dessen für Referenzübergabe-Bindungen verwendet werden.

Beispiel #4 Werte aus dem äußeren Geltungsbereich können nicht durch Pfeilfunktionen geändert werden

<?php

$x 
1;
$fn fn() => $x++; // hat keine Wirkung
$fn();
var_export($x);  // gibt 1 aus

?>

Changelog

Version Beschreibung
7.4.0 Pfeilfunktionen sind verfügbar.

Anmerkungen

Hinweis: Es ist möglich func_num_args(), func_get_arg() und func_get_args() innerhalb einer Pfeilfunktion zu verwenden.

add a note add a note

User Contributed Notes 5 notes

up
6
InvisibleSmiley
4 months ago
Unlike anonymous functions, arrow functions cannot have a void return type declaration.

May seem obvious, but if you thought you could make use of the benefits of arrow functions (using variables from the parent scope) to simplify a function or method call, keep in mind that this is only possible if you do NOT tell PHP that the arrow function does indeed return void.
up
11
Koushil Mankali
9 months ago
In example 4  (Values from the outer scope cannot be modified by arrow functions)

<?php

$x
= 1;
$fn = fn() => $x++; // Has no effect
$fn();
var_export($x);  // Outputs 1

?>

Here we can use reference variable in fn(&$x) and pass the value from function call $fn($x) so that we will get the output as expected with out using Anonymous functions.

Example:

<?php

$x
= 1;
$fn = fn(&$x) => $x++;
$fn($x);
var_export($x);

?>

Output : 2 (as expected)

But here it will not take values from parent scope automatically but we have to pass them explicitly.
up
6
dexen dot devries at gmail dot com
9 months ago
Beware compact() not being able to access (import) variables from external scope (known in versions: 7.4.0, 7.4.8) (bug: https://bugs.php.net/bug.php?id=78970).

A workaround is available - use the variable directly; this will cause it to be imported into the arrow function's namespace and make it available to the compact() too.

<?php
$aa
= 111;
$accessing_variable_works = fn($bb) => [ $aa, $bb ];
$compact_is_broken = fn($bb) => compact('aa', 'bb');
$compact_can_work_with_workaround = fn($bb) => compact('aa', 'bb') + ['workaround' => $aa];
var_dump($accessing_variable_works(333));
var_dump($compact_is_broken(555));
var_dump($compact_can_work_with_workaround(777));
?>

result:
array(2) {
  [0]=>
  int(111)
  [1]=>
  int(333)
}
PHP Notice:  compact(): Undefined variable: aa in /home/m/vlt/guitar/tlb/s/public_html/index.php on line 9
array(1) {
  ["bb"]=>
  int(555)
}
array(3) {
  ["aa"]=>
  int(111)
  ["bb"]=>
  int(777)
  ["workaround"]=>
  int(111)
}
up
0
itsunclexo at gmail dot com
1 month ago
As you already know, variable bindings occur in arrow functions by "by-value".  That means, an arrow function returns a copy of the value of the variable used in it from the outer scope.

Now let us see an example of how a arrow function returns a reference instead of a copy of a value.

<?php

$x
= 0;

$fn = fn &(&$x) => $x// Returns a reference

$y = &$fn($x);  // Now $y represents the reference

var_dump($y);  // Outputs: 0

$y = 3// Changing value of $y affects $x

var_dump($x);  // Ouputs: 3

?>
up
-2
zhangchengming at kkguan dot com
5 months ago
<?php

$x
= 1;

(
fn() => print($x))(); // Outputs 1

(fn($x) => print($x))(2); // Outputs 2
To Top