Contenido del curso
Funciones anónimas
Oscar Andres Yusti Noriega
student
Japheth Calzada López
student
Kenneth Angulo L
student
Yussen Julio Solis Garro
student
Juan Pablo Campuzano Monsalve
student
Daniela Alarcón Gamboa
student
Erick Estrada Mancilla
student
Carlos Eduardo Gomez García
teacher
carlos loera
student
Edgardo Leonel Moreno Castro
student
Abel da Cunha
student
Adan Steven Pedraza Castañeda
student
Jeyson Umaña
studentHallking Quesada Medina
studentHallking Quesada Medina
studentLuis Cano
student
Sergioluis Mendiola
student
David Alejandro González Barba
student
Jorge Guerrero
student
eamedranoc1
studentFUNCIONES 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
Gracias por el aporte
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;
¿Qué resultado te da el ejecutarla?
<?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;
puede haber funciones anónimas dentro de otras funciones anónimas?
Sip, pero esas funciones solo estarían disponibles en el ámbito local de la primer función anónima :D
cual seria la diferencia entre usar use o global ? $change_michi = function(){ global $michi; echo $michi; };
$change_michi = function() use ($michi){ echo $michi; };
por que podríamos hacerlo de estas 2 formas y de las 2 funcionaria
La diferencia es que con use le estás pasando a la función las variables a las que puedes acceder en el scope desde donde la invocas, ya sean locales o globales, pero global solo accede a las variables globales, no a las locales de dicho scope.
Por ejemplo, imagínate que quieres traer datos de una API y procesarlos de cierta forma con un dato externo, imaginémos que sea multiplicar por un número aleatorio, entonces programas algo como esto
<?php function api_call(){ return array(1,2,3,4,5,6,7,8,9); } function external_data(){ return rand(1,10); } function get_data_from_api(){ $api_result = api_call(); $multiply_factor = external_data(); $data = array_map( function($current) use ($multiply_factor) { return $current * $multiply_factor; }, $api_result); return $data; } $data_from_api = get_data_from_api(); print_r($data_from_api); echo "\n";
En este caso si en la función anónima usaramos global para obtener la variable $multiply_factor esta siempre sería null, porque no es una variable global, sino una variable local de get_data_from_api().
Nota que aquí estoy trayendo datos de otra función, pero podría ser una llamada a otra API, un parámetro de la función, datos de una base de datos, o cualquier otra cosa, lo importante es que esta declarada dentro de la función, por lo tanto solo pertenece a ese scope y es inaccesible usando global.
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.
$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).
$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?
Normalmente las funciones anónimas que se usan dentro de funciones como array_map, reciben parámetros del mismo método, entonces, realmente no podrías pasarle la variable en el ámbito global como parámetro, por eso se usa el use, para que el callback distinga de donde va a recibir el valor.
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:
