Mantén la atención ya que en esta división vas a encontrar el arreglo que buscas.Este tutorial ha sido probado por nuestros especialistas para garantizar la calidad y exactitud de nuestro contenido.
Solución:
Las funciones de flecha en PHP se introducen en PHP 7.4. Son un un poco diferente.
La palabra clave fn
El nuevo fn La palabra clave ahora es una palabra clave reservada.
Anteriormente, solíamos seguir usando function palabra clave.
$add = function ($valone,$valtwo)
return $valone + $valtwo;
;
$add(1,2) // 3
Con la llegada de nuevas funciones de flecha:
$add = fn($valone,$valtwo) => $valone + $valtwo;
$add(1,2) // 3
Alcance principal
Anteriormente, tenemos que seguir con el uso de la palabra clave use Para el participación de una variable desde el ámbito principal.
$y = 1;
$fn = function ($x) use ($y)
return $x + $y;
;
echo $fn(2); // 3
La expresión definida en el ámbito principal será implícitamente capturado por valor.
$y = 1;
$fn = fn($x) => $x + $y;
echo $fn(2); // 3
Lo anterior sigue para $this variable dentro de los métodos de la clase.
class foo
public function test()
$context = fn() => var_dump($this);
$context();
$test = new foo();
$test->test(); // object(foo)#1 (0)
Al igual que anteriormente, solíamos realizar nuestras operaciones utilizando el use palabra clave para tomar una variable del ámbito principal, por lo que esto significa que no podemos escribir el valor de la variable de la función en el ámbito superior.
$y = 1;
$fn = fn() => $y++;
$fn(); // Has no effect
echo $y // 1
Si estamos pensando en asignar el valor de otra variable del cierre, esto tampoco funcionará.
$y = 1;
$f = 0;
$fn = fn() => $f = $y + 1;
$fn();
echo $f; // 0
Firmas de funciones
Esto es completamente nuevo en PHP, esto nos permite definir el tipo de función, variable y el valor que devuelve la función.
fn(int $x) => $x; // the argument type must be (int)
fn(): int => $x; // type of return value (int)
Se producen errores cuando el tipo de argumento definido no se coloca en el argumento al llamar a la función. El error se puede detectar utilizando el TypeError escribe
$var = 10;
$int_fn = fn(int $x): int => $x;
var_dump($int_fn($var)); // int(10)
try
$int_fn("foo");
catch (TypeError $e)
echo $e->getMessage(), "n"; // Argument 1 passed to closure() must be of the type int, string given, called in x on line y
Por PHP 7.1, son compatibles con ?type en argumentos que permite que el argumento sea null también.
$funn = fn(?int... $args): array => $args;
var_dump($funn(20, null, 30)); // Array(3) [0]=> int(20) [1]=> NULL [2]=> int(30)
Si proporciona un string o cualquier otra cosa en lugar de int a la función anterior, obtendrá un error
El argumento pasado a cierre () debe ser del tipo int o null, string dado, llamado en x en la línea y
Funciones de flecha anidadas
$var = 6;
var_dump((fn() => fn() => $var)()()); // int(6)
var_dump((fn() => function() use($var) return $var; )()()); // int(6)
Cualquier posible error dentro del cierre. no se tiran a menos que sea llamado
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);
$b = 1;
fn() => $b + $c; // no error, nothing
ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);
$b = 1;
(fn() => $b + $c)(); // Notice: Undefined variable: c in the location on line x
Si el informe de errores está desactivado, obtendrá int(1)
Cómo utilizar PHP. 7.4 ahora?
Para una prueba rápida en línea, simplemente pegue este código allí
Para su sistema nativo, simplemente cloné esta rama de php-src y la compilé usando GCC y make. Hice mis pruebas a través de un archivo test.php y una línea de comando para verificar si todo funciona.
Referencia principal: https://wiki.php.net/rfc/arrow_functions_v2
Las funciones de flecha pueden hacer que su código sea más corto y más legible en algunas situaciones. Fueron diseñados principalmente con la idea de usarlos para devoluciones de llamada simples. Como ejemplo, considere usort() que toma una función de devolución de llamada como parámetro de usuario.
Antes de PHP 7, tenía que hacer algo como esto para definir su propia devolución de llamada para usort():
// old syntax prior to PHP 7
function cmp($a, $b)
if ($a == $b)
return 0;
return ($a < $b) ? -1 : 1;
$a = [3, 2, 5, 6, 1];
usort($a, "cmp");
foreach ($a as $key => $value)
echo "$key: $valuen";
PHP 7 ha agregado un operador de nave espacial y ahora, gracias a las funciones de flecha, puede hacer que su código sea mucho más limpio.
// New syntax since PHP 7.4
$a = [3, 2, 5, 6, 1];
usort($a, fn($a, $b) => $a<=>$b);
foreach ($a as $key => $value)
echo "$key: $valuen";
Pruébelo en línea en 3v4l.org
Las funciones anónimas en PHP pueden ser bastante detalladas, incluso cuando solo realizan una operación simple, de ahí el motivo de una sintaxis más corta. Como otro ejemplo, considere la siguiente función:
// Returns an array with each element squared - old syntax
function array_square($arr)
return array_map(function($x) return $x*$x; , $arr);
// Returns an array with each element squared - new syntax
function array_square($arr)
return array_map(fn($x) => $x**2, $arr);
print_r(array_square([1,2,3,4,5]));
Reducir la sintaxis innecesaria ayuda a comprender el propósito real del código, pero tenga en cuenta que más corto no siempre significa más limpio. Recomendaría tratar las funciones de flecha con la misma precaución que los operadores ternarios. Úselos solo cuando sepa que ayudan a la legibilidad, no solo para acortar su código.