Closure

La funciones anónimas son geniales porque te evitas pensar en nombres para ellas xD

Como aporte: Una función anónima se suele usar muy a menudo como parámetro directo en lugar de guardarlo en una variable (por comodidad)

Los Closures también se llaman callbacks porque son las funciones que son llamadas de regreso al terminar de ejecutar el código de otra función que te la pidió

En este ejemplo podemos usar el Closure para ahorrarnos repetir la misma función de Ordenar pero con distinto criterio (menor a mayor, mayor a menor)

function swap(&$varA, &$varB){    // intercambia los valores de varA y varB
    $aux = $varA;
    $varA = $varB;
    $varB = $aux;
}

function ordenar(Closure $criterio, &$lista){
    for($i = 0; $i < count($lista); ++$i){
        for($j = $i; $j < count($lista); ++$j){

            if( $criterio($lista[$j], $lista[$i]) ){      //Usamos la función pasada como criterio de ordenamiento
                swap($lista[$i], $lista[$j]);
            }

        }
    }
}

$menor = function($A, $B){      //Devuelve true si A es menor que B
    return $A<$B;
};
$mayor = function($A, $B){      //Devuelve true si A es mayor que B
    return $A>$B;
};

$lista = array(4, 2, 1, 5, 3, 1, 74, 154, 2, 4, 9, 10);

echo 'Lista desordenada<br>';
showList($lista);

ordenar($menor, $lista);
echo 'Lista ordenada de menor a mayor<br>';
showList($lista);

ordenar($mayor, $lista);
echo 'Lista ordenada de mayor a menor<br>';
showList($lista);

Esto nos devuelve lo siguiente:

Lista desordenada
L = (4, 2, 1, 5, 3, 1, 74, 154, 2, 4, 9, 10)
Lista ordenada de menor a mayor
L = (1, 1, 2, 2, 3, 4, 4, 5, 9, 10, 74, 154)
Lista ordenada de mayor a menor
L = (154, 74, 10, 9, 5, 4, 4, 3, 2, 2, 1, 1)```

Closure - Funciones anónimas

Una función anónima se usa en una variable que requiere lógica.

<?php

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

echo $greet('Kato');

Al pasarle a una función el parámetro Closure le indica que va ha recibir una función anónimas. Si no colocamos el closure la función va a servir igual, pero puede que se puedan dar muchos tipos de error a futuro, así que es una buena práctica ponerlo.

<?php

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

echo $greet('Kato');

function greet2(Closure $lang, $name)
{
    return $lang($name);
}

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

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

echo greet2($es, 'fea (its a joke, EDN)');
echo greet2($en, 'Karen 🤞');

Aqui un ejemplo de como se puede manejar respuesta de apis usando funciones anonimas

function handleResponse(Closure $type, $message) {
  return $type($message);
}

$success = function ($message) {
  return [
    'status' => 200,
    'message' => $message
  ];
};

$fail = function ($message) {
  return [
    'status' => 400,
    'message' => $message
  ];
};

echo "<pre>";
var_dump(handleResponse($success, 'El request fue exitoso'));
var_dump(handleResponse($fail, 'Bad Request'));

MIs apuntes

<?php

echo "<h1>Closure</h1>";
echo "---------------";
echo "<br>";
//Función Anonima 

/*
$greet = function ($name){ //Variable que requiere lógica
	return "<h1>Hola, $name</h1>"; 
};

echo greet('Danny');
*/

function greet(Closure $lang, $name){
	return $lang($name);
}

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

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

echo greet($es, 'Danny');
echo "<br>";
echo greet($en, 'Danny');

Hola a todos les dejo mis apuntes de la clase con un poco de investigación fuera de ella para enriquecer el ejercicio 💚.

Ejemplo de Closure, Me gusto esta caracteristica, aqui calcule un valor de pesos COP , para cuando quiera viajar a europa o japon ya sepa la conversion 😃

<?php

function conversionDePesosCopA(Closure $moneda,$valor){
    return $moneda($valor);
}

$dolar=function($valor){
    $resultado= $valor/3711.60;
    return $resultado." USD <br>";
};

$euro=function($valor){
    $resultado=$valor/4507.71;
    return "$resultado EUR <br>";
};

$yen=function($valor){
    $resultado=$valor/33.9403;
    return "$resultado JPY <br>";
};

echo conversionDePesosCopA($dolar,1280000);
echo conversionDePesosCopA($euro,1280000);
echo conversionDePesosCopA($yen,1280000);
?>

🤔 Con clousure podemos representar funciones anónimas, funciones que no tienen un identificador.

Funciona, pero hay mejores practicas??

function operadores(Closure $tipo, $valor, $valor2)
{
    return $tipo($valor,$valor2);
}
$multiplica = function ($valor, $valor2)
{ 
    $resultado = $valor * $valor2;
    return "La multiplicación de $valor por $valor2 es $resultado";

};
$resta = function ($valor, $valor2)
{ 
    $resultado = $valor - $valor2;
    return "La resta de $valor por $valor2 es $resultado";
     
};
$division = function ($valor, $valor2)
{ 
    $resultado = $valor / $valor2;
    return "La división de $valor por $valor2 es $resultado";
     
};

echo operadores($multiplica,15,10)."<br/>";

echo operadores($resta,15,10)."<br/>";


echo operadores($division,15,15)."<br/>";```

El mejor profesor lejos !!

Ejercicio de operaciones aritméticas:

<?php

function operacionMatematica(Closure $operation, $num1, $num2)
{
    return $operation($num1, $num2);
}

$suma = function ($num1, $num2)
{
    return $num1 + $num2;
};

$resta = function ($num1, $num2)
{
    return $num1 - $num2;
};

$multiplicacion = function ($num1, $num2)
{
    return $num1 * $num2;
};

$division = function ($num1, $num2)
{
    if( $num2!=0 ){
        return $num1 / $num2;
    }
    return "operación no permitida, divisor no puede ser igual a cero";
};

//escribir en el primer parámetro el nombre de la función anónima
echo operacionMatematica($suma, 65, 15);

Recuerden que podemos tener cualquier cantidad de parámetros en las funciones anónimas, hagan ejercicios sencillos y prácticos como éste que les comparto para que tengan más claro el concepto.

Saludos y recuerden nunca parar de aprender ❤️

Se tiene que tener mucho cuidado con el uso de funciones anónimas, facilmente podemos terminar con un código espagueti

🍃 En el código anterior, se utiliza el concepto de clousures en PHP. Un closure es una función anónima, es decir, una función sin nombre que se puede almacenar en una variable y que puede tener acceso a las variables externas a la función.

En este caso, las variables $es y $en son clousures que reciben un parámetro $name y devuelven una cadena de saludo en español y en inglés, respectivamente.

La función greet() recibe dos argumentos: una variable de tipo Closure y una variable $name. La variable de tipo Closure es la función anónima que se va a ejecutar y el argumento $name es el nombre que se va a usar en el saludo.

Finalmente, se llama a la función greet() dos veces, una vez con el closure $es y otra vez con el closure $en, y se pasa el argumento “Lynda” como el valor de $name. Esto causará que se devuelva un saludo en español y en inglés, respectivamente.

En resumen, los clousures permiten crear funciones dinámicas y flexibles, y se utilizan comúnmente para trabajar con callbacks y para crear funciones de alto nivel que tienen acceso a variables y estado externos.

// Declaración de la función greet que recibe dos argumentos: un closure y un nombre
function greet(Closure $lang, $name) {
  // La función greet retorna el resultado de la ejecución del closure
  return $lang($name);
}

// Declaración de la variable $es, la cual es un closure
$es = function ($name) {
  // El closure $es retorna un saludo en español
  return "hola, $name";
};

// Declaración de la variable $en, la cual es un closure
$en = function ($name) {
  // El closure $en retorna un saludo en inglés
  return "Hello, $name";
};

// Llamada a la función greet con el closure $es y el nombre "Lynda"
echo greet($es, "Lynda");

// Llamada a la función greet con el closure $en y el nombre "Lynda"
echo greet($en, "Lynda");
 

En resumen, los clousures permiten crear funciones dinámicas y flexibles, y se utilizan comúnmente para trabajar con callbacks y para crear funciones de alto nivel que tienen acceso a variables y estado externos.

Funcion para obtener la semana, el dia, mes o año de una fecha

<?php

function getVal(Closure $format, $date)
{
    $date =  strtotime($date);
    return $format($date);
}

$mounth = function($date)
{
    return date("m",$date);
};

$year = function($date)
{
    return date("Y", $date);
};

$week = function($date)
{
    return date("W", $date);
};
$day = function($date)
{
    return date("d",$date);
};


echo getVal($week, date("d-m-Y"));

Hola, hice un pequeño ejercicio con un formulario usando variables variables para poder llamar dinámicamente al Closure

<?php

function greet(Closure $lang, $name){
	return $lang($name);
}

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

$en = function ($name){
	return "Hello, $name";
};
$lang = $_GET['lang'] ?? false;
$name = $_GET['name'] ?? false;

if($lang){
	echo greet($$lang, $name);
	echo "<br>";
}

?>
		<form action="/">
			<div class="lang">
        <input type="text" name="name" id="name" placeholder="Nombre" required/>
				<br>
				<input type="radio" value="en" id="en" name="lang"/>
				<label for="en" class="radio">English</label>
				<input type="radio" value="es" id="es" name="lang" />
				<label for="es" class="radio">Español</label>
			</div>
        <hr>
        <div>
          <button type="submit" href="/">Submit</button>
        </div>
		</form>

No use los clousers pero me dio el mismo resultado:

function Saludar($idioma, $persona){
    if ($idioma == 'es'){
        return "Hola, $persona";
    };
     if ($idioma == 'en'){
        return "hello, $persona";
    };
}

echo Saludar('en', 'Monica');

Funciones anónimas y la palabra reservada Closure

Hice este ejemplo muy sencillo con divisas pero me agradó bastante el resultado, es algo muy práctico.

<?php
    $cambio = function(Closure $divisa, $valor)
    {
        return $divisa($valor);
    };

    $mnx = function($value)
    {
        return "Esta moneda vale " . $value * 0.056 . " dólares.";
    };

    $arg = function($value)
    {
        return "Esta moneda vale " . $value * 0.0029 . " dólares.";
    };

    echo $cambio($mnx, 100);

    echo "\n";
?>

<code> 

<?php

namespace App;

use Closure;
use Exception;

class CheckUser
{
    private $name;
    private $email;
    private $request;

    public function checkNameAndEmail(Closure $next, $name, $email)
    {
        if (!$name || !$email) {
            throw new CheckUserException('Name and email is required');
        }

        $this->name = $name;
        $this->email = $email;

        $this->request = $next($this);

        return $this->request;
    }

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;

        return $this;
    }

    public function getName()
    {
        return $this->name;
    }

    public function setName($name)
    {
        $this->name = $name;

        return $this;
    }
}

class CheckUserException extends Exception
{
}

<?php

use PHPUnit\Framework\TestCase;
use App\CheckUser;

class CheckUserTest extends TestCase
{
    public function test_check_name_and_email()
    {
        $checkUser = new CheckUser();
        $checkUser->setName('User Test');
        $checkUser->setEmail('[email protected]');
        $next = function ($checkUser) {
            return $checkUser;
        };

        $request = $checkUser->checkNameAndEmail($next, $checkUser->getName(), $checkUser->getEmail());

        $this->assertInstanceOf(CheckUser::class, $request);
    }
}

$greet = function ($name) { //para variables que requieran logica
  return "Hola $name";
};

$greet("Ivan");

//Estás funciones se usan para pasarse cómo parametros a otras funciones
//Es decir un "Callback" cómo en Javascript c:

function greeting2(Closure $lang,$name){
  return $lang($name);
}

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

greeting2($es, "Ivan");

Si es un tema complejo debido a las palabras usadas.
.
Pero de esta manera sencilla y clara entendimos esta gran definicion !! 🏆
.
Grande profesor Italo !!, ojala hubiera tenido un profesor asi en la U. que explicara con palabras claras que es cada cosa.
.

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

// $es almacena una funcion anonima, sin nombre.
$es = function ($name) {
    return "Hola, {$name}";
};

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

• Una función anónima se usa en una variable que requiere lógica.

en mis dos años aprendiendo programacion y 4 años de carrera, este ha sido el unico curso, profesor y video que me ha dejado muy MUY claro que es y como usar una funcion anonima<3

recuerden:

Una función anónima se usa en una variable que requiere lógica.

Ejercicio 3

Resumen de la clase

<?php
/* $greet = function ($name){ //Varriable que requiere logica
    return "Hello $name";
};

echo $greet('World');
 */

 function greet(Closure $lang,$name){
    return $lang($name);
 }

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

 echo greet($es,'Linda');
 
echo '<br>';

Saludos segun el horario.

function greet(Closure $saludo, $name){

    return $saludo($name);
};

$morning = function($name){
 return "Buen dia, $name";
};

$afternoon = function(){
    return "Buenas tardes, $name";
};

$night = function(){
 return "Buenas noches, $name";
};

echo greet($morning, 'Lynda');

Esta clase fue muy JavaScript para mi jajaja

Excelente explicación para las funciones anónimas, una variable que tiene lógica.

``
<?php
// Your code here!
function datos(Closure $message, $user, $id) {
return $message($user, $id);
}

$welcome = Function ($user, $id) {
return " Welcome User:
Name: $user
Cel: $id";
};

echo datos($welcome, ‘Juan alvarez’, ‘7766433’);

?>

<?php
// Your code here!
function datos(Closure $new, $name, $cel) {
return $new($name, $cel);
}

$client = Function ($name, $cel) {
return " Registrando clientes:
Name: $name
Cel: $cel";
};
$search = Function ($name, $cel) {
return " Encontramos 1 existente:
Name: $name
Cel: $cel";
};

echo datos($search, ‘Juan alvarez’, ‘4424242724’);

?>

<?php
function store(Closure $price, $producto) {
return $price($producto);
}

$leche = Function ($price) {
return " <h3>Registrando precios </h3>
Cuesta: $price";
};
$sabritas = Function ($price) {
return “Cuesta: $price”;
};

echo store($leche, ‘120’);

?>

10. Closure

Comparto el código que realizamos en clase:

<?php

/**
 * Una función anónima se usa en una variable que
 * requiere lógica.
 * Nos referimos a esta función anónima por el nombre
 * de la función
 */
/*
$greet = function ($name)
{
    return "Hola, $name";
};

echo $greet('Aldo');
*/

/**
 * Al poner Clousure podemos asegurar que se necesita
 */

function greet(Closure $lang, $name)
{
    return $lang($name);
}

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

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

echo greet($es, 'Aldo');

Casi no lo logro, comprendí el concepto general, pero falta practicarlo, ¿alguien algunos ejercicios practicos?

function reordenar(Closure $funtion, $a, $b)
{
    $result = $funtion($a, $b);

    $aux = $result[0];
    $result[0] = $result[1];
    $result[1] = $aux;
    return [$result[0], $result[1]];
}

$desordenar = function($a, $b)
{
    $aux = $a;
    $a = $b;
    $b = $aux;
    return [$a, $b];
};

echo "<pre>";
var_dump($desordenar('hola', 'chao'));
echo "<br>";
var_dump(reordenar($desordenar, 'hola', 'chao'));

Pienso que la forma mas facil de recordar a Closure, es decir que se puede instanciar con la clase Closure una funcion anonima para pasarle parametros dentro de otra funcion.

Segun la clase closure nos sirve para indicar que la variable que pasamos como argumento es de funcion anonima, pero si quito closure sigo recibiendo el mismo resultado como si lo tuviera. Y removiendo closure no entiendo porque la relacion de la variable $lang con $es y $en sigue funcionando.

Me podria ayudar a comprender?

Gran explicación, por fin pude entender las variables anonimas, muchas gracias 😄

Función anónima

Excelente clase

Me gusto mucho esta clase.

Según entiendo las clases anónimas son útiles cuando es necesario crear objetos sencillos; les dejo un pequeño aporte para el calculo del área de figuras geométricas, le inclui algunas reglas de verificación PHP 7.

<?php

// Handle response
function responseFormat(int $status, string $name, string $formula, float $data): array
{
  return [
    'status' => $status,
    'figure' => $name,
    'formula' => $formula,
    'result' => $data
  ];
}

// calculate
function calculateArea(Closure $figure, float $base, float $height): array
{
  return $figure($base, $height);
}

// anonymous
$triangle = function (float $base, float $height): array {
  return responseFormat(200, 'Triangle', 'B x H / 2', $base * $height / 2);
};

// anonymous
$square = function (float $base, float $height): array {
  return responseFormat(200, 'Square', 'B x H', $base * $height);
};

// validate
$base = isset($_GET['base']) ?? 10;
$height = isset($_GET['height']) ?? 20;

// view
echo "<pre>";
print_r(calculateArea($triangle, $base, $height));
print_r(calculateArea($square, $base, $height));

Ejercicio con potencias y json:

// Una Funcion que recibe una función anonima
function Funcion(Closure $xfunc, $ytext){
return $xfunc($ytext);

}
//Calculando la Potencia
$fun_anoni_01=function($base){
return pow($base,3);
};
//Creando del json
$fun_anoni_02=function($f){
return json_encode($f);
};

echo Funcion($fun_anoni_01,3)."<br>";

//Array Asociativo
$texto[]=[“Nombre”=>“Willi”, “Apellido”=>“Wonka”];

echo Funcion($fun_anoni_02,$texto)."<br>";

Comparto mi ejemplo 😄

<?php

function calculadora(Closure $operation, $value1, $value2)
{
    return $operation($value1, $value2);
}

$suma = function($value1, $value2)
{
    $resultado = $value1 + $value2;
    return "La suma de $value1 mas $value2 es: $resultado";
};

$multi = function ($value1, $value2) {
    $resultado = $value1 * $value2;
    return "La multiplicación de $value1 * $value2 es: $resultado";
};

$resta = function ($value1, $value2) {
    $resultado = $value1 - $value2;
    return "La resta de $value1 menos $value2 es: $resultado";
};

echo calculadora($resta, 1, 2);
echo '<br>';
echo calculadora($resta, 1, 2);
echo '<br>';
echo calculadora($multi, 1, 2);

Hacer uso de funciones anónimas combinadas con Closures es genial y el limite de su uso es la imaginación. Les comparto un pequeño conversor de monedas con estas funcionalidades:

<?php

echo "Conversor de USD a otras monedas.<br><br><br>";

function convertUSD(Closure $coin, $quantity)
{
  return $coin($quantity);
}

$convertToMx = function($quantity)
{
  $money = 20.38;
  $convert = $quantity * $money;
  return "1 dolar vale $money pesos mexicanos y $quantity USD son $convert Pesos Mexicanos.<br><br>";
};

$convertToEur = function($quantity)
{
  $money = 1.22;
  $convert = $quantity * $money;
  return "1 euro vale $money dolares y $quantity USD son $convert Euros.<br><br>";
};

$convertToGold = function($quantity)
{
  $money = 0.0005547175;
  $convert = $quantity * $money;
  return "1 dolar vale $money onzas de oro y $quantity USD son $convert onzas en Oro.";
};

echo convertUSD($convertToMx, '5');
echo convertUSD($convertToEur, '320');
echo convertUSD($convertToGold, '10000');

También se puede pasar la función anónima directamente como parámetro al invocar a la función greet:

<?php

function greet(Closure $lang, $name)
{
    return $lang($name);
}

echo greet(function ($name)
        {
            return "Hola, $name";
        }, 'Lynda');

echo '<br>';

echo greet(function ($name)
        {
            return "Hello, $name";
        }, 'Lynda');

Me parece interesante que aún sin poner la clase Closure en el argumento $idioma de la función saludar_en_idioma() siga funcionando y es más, se sigue reconociendo (en este caso $idioma) como un objeto de esta clase.

 function saludar_en_idioma($idioma, $name)
 {
     return $idioma($name);
 }

 $latino = function($name){
     return "Hola que tal, $name";
 };

 $ingles = function($name){
     return "Hi, how are you $name";
 };

echo saludar_en_idioma($latino, "David");

<?php

//Una función anonima se utiliza cunado se requiere que una variable tenga lógica
//Closure: nos permite validar que lo que pasamos sea una función anónima.

$tes = function($name = 'Invitado'){
    return "Hola, $name <br>";
};

echo $tes('Guillermo Pagan');

function greet(Closure $lang, $name ){
    return $lang($name);
}

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

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

echo greet($en, 'Guillermo Pagan');