Advertisement
  1. Code
  2. PHP

Funciones anónimas y funciones flecha en PHP

Scroll to top
Read Time: 9 min

Spanish (Español) translation by Ana Paulina Figueroa (you can also view the original English article)

Ya he hablado sobre los conceptos básicos de las funciones en PHP en uno de los tutoriales anteriores. Si bien PHP tiene muchas funciones integradas, este también nos da la opción de definir nuestras propias funciones. Existen diferentes formas de definir nuestras propias funciones en PHP.

Este tutorial te enseñará las características y usos de las funciones anónimas en PHP. También aprenderás sobre la sintaxis de la función flecha más reciente en PHP.

Funciones anónimas en PHP

Cada vez que definimos una función en PHP, normalmente también le proporcionamos un nombre. Este nombre se usa para llamar a la función posteriormente cada vez que la necesitamos. Sin embargo, en algunas ocasiones una función es necesaria solamente en un lugar específico. Digamos que estás trabajando en un extenso proyecto que requiere que escribas alrededor de 50 o más funciones de ese tipo.

En tales casos, es mucho más sencillo simplemente colocar la definición de la función en donde sea necesaria, sin preocuparte por encontrar un nombre para la función. Estos tipos de funciones se conocen como funciones anónimas. Estas son particularmente útiles cuando trabajas con funciones que tienen solamente cuatro o cinco líneas de longitud.

Cómo implementar devoluciones de llamadas con funciones anónimas

Uno de los usos más comunes de las funciones anónimas es como devoluciones de llamadas. Las funciones de devolución de llamada son invocadas por la función principal para realizar alguna tarea basada en la lógica que proporciones. Podemos usar tanto funciones integradas como funciones definidas por el usuario como devoluciones de llamadas. Aquí puedes ver un ejemplo de tales funciones:

1
<?php
2
3
$numbers = [12, 18, 5, 11, 10, 95, 3];
4
5
$multiple_five = array_filter($numbers, function($n) {
6
    return $n%5 == 0;
7
});
8
9
print_r($multiple_five);
10
/*

11
Array

12
(

13
    [2] => 5

14
    [4] => 10

15
    [5] => 95

16
)

17
*/
18
19
?>

En el código anterior, simplemente devolvemos múltiplos de cinco de una determinada matriz de números. El segundo parámetro de array_filter() es nuestra función de devolución de llamada. Como puedes ver, esta realiza la trivial tarea de simplemente verificar si un número es divisible por cinco. Si no tuviéramos funciones anónimas, tendríamos que definir esta función en algún otro lugar y crear un nombre que no causara conflictos.

Cómo asignar funciones anónimas a variables

En PHP, por lo general asignamos un nombre a cualquier función que hayamos definido. Este nombre se usa para llamar a la función posteriormente cada vez que se necesite. Sin embargo, las funciones anónimas no tienen nombre. Esto puede ocasionar que sea difícil para nosotros invocarlas posteriormente si surge la necesidad.

Una característica interesante de las funciones anónimas es que podemos asignarlas a variables o almacenarlas en el interior de matrices numéricas o asociativas. Después de eso, simplemente podemos llamar a estas funciones usando el nombre de la variable. Aquí puedes ver un ejemplo:

1
<?php
2
3
$padded = function($word) {
4
    echo str_pad($word, 10, "_", STR_PAD_BOTH);
5
};
6
7
8
$word_funcs = [
9
    'capital' => function($word) {
10
        echo strtoupper($word);
11
    },
12
    'reversed' => function($word) {
13
        echo strrev($word);
14
    }, 
15
    'rotated' => function($word) {
16
        echo str_rot13($word);
17
    }, 
18
];
19
20
$padded("banana");
21
// __banana__

22
23
$word_funcs['capital']("mango");
24
// MANGO

25
?>

Como puedes ver en el código anterior, estas funciones anónimas pueden asignarse a variables y ser invocadas como si fueran funciones regulares.

Las funciones anónimas pueden heredar variables del ámbito principal

En uno de nuestros artículos anteriores, llamado "Comprende el ámbito de las variables en PHP", cubrimos el ámbito de las variables en detalle. Básicamente, PHP tiene un ámbito global y un ámbito a nivel de función. En el interior de tus funciones, no puedes acceder a variables definidas en algún otro lugar. De manera similar, las variables definidas en el interior de una función no serán accesibles fuera de ella.

Una forma de acceder a variables externas dentro de una función es mediante el uso de la palabra clave global. Sin embargo, este enfoque tiene algunas desventajas, ya que puede dificultar el mantenimiento del código a largo plazo.

PHP también tiene la palabra clave especial use, que te permite acceder a variables del ámbito principal dentro de una función anónima. Entendamos la diferencia entre global y use con algunos ejemplos:

1
<?php
2
3
// Global Scope

4
$pad = '@';
5
$full_length = 20;
6
7
function parent_function() {
8
9
    // Parent Scope

10
    $pad = '#';
11
    $full_length = 16;
12
13
    function padding($word) {
14
        global $pad;
15
        global $full_length;
16
17
        echo str_pad($word, $full_length, $pad, STR_PAD_BOTH);
18
        $full_length = 40;
19
    };
20
21
    padding('banana');
22
}
23
24
parent_function();
25
// @@@@@@@banana@@@@@@@

26
27
echo $full_length;
28
// 40

29
30
?>

En el ejemplo anterior, hemos definido las variables $pad y $full_length dos veces. Estas son parte del alcance global cuando se definen en la parte superior. Definimos esas dos variables nuevamente dentro de la función parent_function(). Sin embargo, estas no tienen relación con las variables definidas en el ámbito global, ya que en PHP las funciones tienen su propio ámbito.

Cuando usamos estas variables dentro de nuestra función padding() con la ayuda de la palabra clave global, en realidad estamos accediendo a los valores globales. Esto es evidente cuando vemos la salida de parent_function(). También pudimos cambiar el valor de la variable global $full_length dentro de nuestra función.

Podemos reescribir el código anterior para usar funciones anónimas y la palabra clave use. Esto se verá como el fragmento de código mostrado a continuación:

1
<?php
2
3
// Global Scope

4
$pad = '@';
5
$full_length = 20;
6
7
function parent_function() {
8
9
    // Parent Scope

10
    $pad = '#';
11
    $full_length = 16;
12
13
    $padding = function($word) use ($pad, $full_length) {
14
        echo str_pad($word, $full_length, $pad, STR_PAD_BOTH);
15
        $full_length = 40;
16
    };
17
18
    $padding('banana');
19
20
    echo $full_length;
21
    // 16

22
}
23
24
parent_function();
25
// #####banana#####

26
27
echo $full_length;
28
// 20

29
30
?>

Esta vez hemos creado nuestra función padding para que sea anónima y accedemos a $pad y a $full_length con la ayuda de la palabra clave use. El valor de estas variables se tomó del ámbito principal. La eliminación de las variables del ámbito global ocasionará errores relacionados con variables indefinidas.

Además, observa que la función anónima en realidad está trabajando con las copias de las variables del ámbito principal. Es por eso que el valor de $full_length no cambio en el exterior de la función anónima.

Puedes enviar estas variables por referencia si quieres que esos cambios se reflejen fuera de la función.

Cómo lograr que las funciones de devolución de llamada anónimas sean más versátiles

Al comienzo de este tutorial, aprendimos que las funciones anónimas se usan comúnmente como devoluciones de llamadas. Hicimos una demostración de esto usando la función array_filter(). En ese ejemplo, filtramos todos los números de nuestra matriz que no fueran múltiplos de 5. Este 5 fue codificado de manera fija en la función de devolución de llamada.

¿Qué pasaría si quisiéramos que nuestra función de filtro fuera más versátil, de manera que pueda filtrar los números que no sean múltiplos de otros valores, como 8 o 10? Una forma de hacerlo sería enviar el otro número como segundo parámetro.

Desafortunadamente, la función de devolución de llamada espera recibir una cantidad específica de parámetros (uno en este caso). Por lo tanto, enviar dos parámetros ocasiona un error. Podemos superar esta limitación con la ayuda de la palabra clave use. Como vimos en la sección anterior, las funciones anónimas pueden heredar variables del ámbito principal con la palabra clave use. Aquí puedes ver una versión modificada de nuestra devolución de llamada que se basa en este hecho.

1
<?php
2
3
$numbers = [12, 18, 5, 11, 10, 95, 3];
4
5
$factors = [2, 3, 5];
6
7
foreach($factors as $factor) {
8
    $multiples = array_filter($numbers, function($n) use ($factor) {
9
        return $n%$factor == 0;
10
    });
11
    echo "Multiples of $factor\n";
12
    print_r($multiples);
13
}
14
15
/*

16


17
Multiples of 2

18
Array

19
(

20
    [0] => 12

21
    [1] => 18

22
    [4] => 10

23
)

24
Multiples of 3

25
Array

26
(

27
    [0] => 12

28
    [1] => 18

29
    [6] => 3

30
)

31
Multiples of 5

32
Array

33
(

34
    [2] => 5

35
    [4] => 10

36
    [5] => 95

37
)

38


39
*/
40
41
?>

Creamos una matriz con una serie de factores cuyos múltiplos queremos filtrar. Después de eso, usamos un bucle foreach para recorrer los factores. Cada factor se envía a la función de devolución de llamada para que array_filter() nos proporcione múltiplos para todos ellos.

Funciones flecha en PHP

Básicamente, las funciones flecha son una forma más corta de escribir funciones anónimas simples. Fueron introducidas en PHP 7.4. La palabra clave function se reemplaza con fn, y la palabra clave return se omite por completo al definir funciones flecha. Estas solamente contienen una expresión, y esa expresión es el valor de retorno de la función flecha.

Otra característica más de las funciones flecha es que las variables definidas en el ámbito principal están disponibles de manera implícita para ellas sin tener que agregar la palabra clave use.

1
<?php
2
3
$numbers = [12, 18, 5, 11, 10, 95, 3];
4
5
$factors = [2, 3, 5];
6
7
foreach($factors as $factor) {
8
    $multiples = array_filter($numbers, fn($n) => $n%$factor == 0);
9
    echo "Multiples of $factor\n";
10
    print_r($multiples);
11
}
12
13
/*

14


15
Multiples of 2

16
Array

17
(

18
    [0] => 12

19
    [1] => 18

20
    [4] => 10

21
)

22
Multiples of 3

23
Array

24
(

25
    [0] => 12

26
    [1] => 18

27
    [6] => 3

28
)

29
Multiples of 5

30
Array

31
(

32
    [2] => 5

33
    [4] => 10

34
    [5] => 95

35
)

36


37
*/
38
39
?>

La ejecución de este código genera los mismos valores que se obtuvieron con el fragmento de código anterior. Como mencioné anteriormente, la variable $factor se encuentra disponible para nuestra función flecha sin tener que agregar la palabra clave use.

Pensamientos finales

En este tutorial cubrimos algunas características y usos de las funciones anónimas en PHP. Esto incluye aspectos como su uso para crear devoluciones de llamadas o el asignarlas a variables para llamarlas posteriormente. También aprendimos cómo podemos acceder a las variables definidas en el ámbito principal dentro de las funciones anónimas. Más adelante, usamos esta característica para crear funciones de devolución de llamada más útiles.

También aprendimos que las funciones anónimas simples se pueden escribir de manera más concisa usando la sintaxis de la función flecha.

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.