No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Curso de Manejo de Datos en PHP

Curso de Manejo de Datos en PHP

Profesor Italo Morales F

Profesor Italo Morales F

Closure

10/16
Recursos

Aportes 53

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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 鈥淟ynda鈥 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

Mucha muchas gracias.. lo entendi muy bien. Gracias profesor por la explicacion.
Esto es lo mas b谩sico que se me ocurri贸```js function pets(Closure $animal, $name){ return $animal($name); } $cat = function($name) { return "Tengo un $name"; }; $dog = function($name) { return "Tengo un $name"; }; echo pets($dog, 'Perro'); ```
```html
隆Hola!, revisando el c贸digo, c```js

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

Es como un callback en JS

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, 鈥楯uan 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, 鈥楯uan 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 鈥淐uesta: $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[]=[鈥淣ombre鈥=>鈥淲illi鈥, 鈥淎pellido鈥=>鈥淲onka鈥漖;

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');