No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Funciones anónimas

21/25
Recursos

Aportes 13

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

FUNCIONES ANONIMAS

Las funciones anónimas o también conocidas como Closures son funciones que podemos definir sin necesidad de asignarles un nombre. Son muy similares a los callbacks de Javascript

Las podemos guardar dentro de variables, pero su uso mas común es pasarlas como parámetro de otra función.

Las funciones anónimas son una instancia de la clase Closure

<?php

$numbers = [1,2,3,4];

$numbers_by_2 = array_map(function($current){
    return $current * 2;
},$numbers);

print_r($numbers_by_2);

echo "\n";

Cuando queremos que una variable externa exista dentro de un Closure sin necesidad de pasarla como parámetro podemos usar la palabra reservada “use”

$michi = "Mr.Michi";

$change_michi_name = function() use($michi){
    echo $michi;
};

$change_michi_name();
echo "\n";

Con “use” cambiamos el ambito de la variable de global a local y la podemos usar dentro del closure,
pero debemos tener en cuenta que solo podemos leerla, mas no cambiar su valor

Quiero compartirles apuntes de las clases con el rofesor Italo, donde se explica lo mismo con palabras mas puntuales.

<?php

// Una funcion anonima se usa en un a variable que requiere logica
$greet = function ($name) {
    return "HOla {$name}";
};

echo $greet('Kenneth');
echo "<br>";


function saludar(Closure $lang, $name)
{
    // $lang es la variable que contiene la funcion anonima
    // la palabra closure, es un parametro de PHP que indica:
    // 'requiero que esa variable sea una funcion'
    return $lang($name);
}

$es = function ($name) {
    return "Hola, {$name}";
};

$en = function ($name) {
    return "Hello, {$name}";
};


echo saludar($es, "Lynda");
echo "<br>";
echo saludar($en, "Brenda");
echo "<br>";

video minuto 9:24, si usamos la referencia de la variable global si la podríamos sobrescribir y asignarle un nuevo valor

<?php
$michi = “Mr. Michi”;
$change_michi_name= function() use(&$michi){
$michi = “Mr.Michis2”;
};
$change_michi_name();
echo $michi;
<?php

$numbers = [1,2,3,4];
$number_multiply = readline("Escribe el numero por el cual quieres multiplicar: ". PHP_EOL);
$numbers_by_2 = array_map(function($current) use ($number_multiply) {
    return $current * $number_multiply;
},$numbers);

print_r($numbers_by_2);

echo PHP_EOL;
En PHP, una función anónima es una función sin un nombre específico. Se crean utilizando la palabra clave `function` seguida de paréntesis que pueden contener parámetros, y luego el cuerpo de la función. No se les asigna un nombre como las funciones regulares. En su lugar, se almacenan en una variable o se utilizan directamente en el contexto en el que se necesitan. ```php $sumar = function($a, $b) { return $a + $b; }; // Uso de la función anónima $resultado = $sumar(3, 5); echo $resultado; // Esto imprimirá 8 ``` En este ejemplo, hemos creado una función anónima que toma dos parámetros y devuelve la suma de ellos. Luego, la asignamos a la variable `$sumar` y la llamamos posteriormente. Las funciones anónimas son especialmente útiles cuando necesitas pasar una función como argumento a otra función, como en el caso de funciones de orden superior o cuando trabajas con funciones de devolución de llamada (callbacks). Adicionalmente, en PHP, puedes utilizar la función `use` para capturar variables desde el ámbito que rodea la función anónima (clausura). ```php $mensaje = "Hola desde el ámbito externo"; $mostrarMensaje = function() use ($mensaje) { echo $mensaje; }; $mostrarMensaje(); // Esto imprimirá "Hola desde el ámbito externo" ``` En este caso, la función anónima tiene acceso a la variable `$mensaje` gracias a la cláusula `use`.

no entendí la diferencia entre global y use

Retaxmaster siempre le colocas humor a las clases, “Un Array que contenga 1,2,3,4 por que soy muy creativo” jajajaja. Excelente sigue con esa actitud.

para acceder al ambito global de una variable en una funcion exiten varios metodos.

Global

$a = 1;
$b = 2;

function Suma()
{
    global $a, $b;

    $b = $a + $b;
}

/*También podemos hacer uso de global de la siguiente manera*/

$foo = "variable local";

function test() {
    echo '$foo en el ámbito global: ' . $GLOBALS["foo"] . "\n";
    echo '$foo en el ámbito simple: ' . $foo . "\n";
}

Otra forma es usando la referencia del lugar en memoria de la variable

$var = "tests";

function foo(&$var) { }

y la que aprendimos en esta clase que es haciendo uso de use

$message = 'hello';

$example = function () use ($message) {
    var_dump($message);
};

esto es parte de la clase de php básico.

En la siguiente clase veremos arrow functions y aquí les dejo un ejemplo de como lograr lo mismo que el profe pero con arrow function.

$numbers = [2,4,6,8];

$by_2 = array_map(fn($current) => $current * 2, $numbers);

print_r($by_2);

Si use solo lee el valor, y no lo puede modificar, ¿por qué no simplemente se pasa dicho valor como argumento generando un nuevo parámetro en la función anónima? ¿Cuál es la diferencia?

Codigo de la clase:

<?php
/* $numbers = [1,2,3,4,5,6,7,8,9,10];
$numbers_by_2 = array_map(function($current){
    return $current*2;
},$numbers);

print_r($numbers_by_2);
 */

 $michi = "MICHI";
 $change_michi_game = function() use ($michi){
    echo $michi;
 };
$change_michi_game();


?>
Me gustó mas esta forma: ![](https://static.platzi.com/media/user_upload/image-6e54d88b-9386-4771-940c-396132fbd3e7.jpg)