PHP Academy · Lección

Funciones anónimas y closures

Escriba funciones inline y capture variables mediante use.

Funciones anónimas y closures es una lección gratuita de PHP Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de PHP Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué son las funciones anónimas?

Una función anónima (lambda) es una función sin nombre. En PHP, es una instancia de la clase integrada Closure y puede almacenarse en una variable, pasarse como argumento o devolverse desde otra función.

Función anónima básica

Asigne una función a una variable y llámela:

<?php
$double = function(int $n): int {
    return $n * 2;
};

echo $double(5);   // 10
echo $double(21);  // 42

Pasar funciones anónimas

Pase una closure como argumento a funciones como array_map, usort o sus propias funciones de callback:

<?php
$nums = [3, 1, 4, 1, 5, 9];

$squared = array_map(function(int $n): int {
    return $n ** 2;
}, $nums);

print_r($squared); // [9, 1, 16, 1, 25, 81]

Devolver funciones

Una función puede crear y devolver una closure; este es un patrón de fábrica:

<?php
function makeMultiplier(int $factor): Closure {
    return function(int $n) use ($factor): int {
        return $n * $factor;
    };
}

$triple  = makeMultiplier(3);
$tenX    = makeMultiplier(10);

echo $triple(5);   // 15
echo $tenX(5);     // 50

Closures y use

Las closures pueden capturar variables del ámbito externo mediante use. La captura se realiza por valor (copia), a menos que añada &:

<?php
$taxRate = 0.18;

$addTax = function(float $price) use ($taxRate): float {
    return $price * (1 + $taxRate);
};

$taxRate = 0.20;  // change outer variable
echo $addTax(100); // 118 — captured value at creation time

Captura por referencia con use(&)

Para que la closure vea los valores externos actualizados, capture por referencia:

<?php
$count = 0;

$increment = function() use (&$count): void {
    $count++;
};

$increment();
$increment();
echo $count;  // 2

Funciones flecha (PHP 7.4)

Las funciones flecha son closures compactas de una sola expresión que capturan automáticamente el ámbito externo por valor:

<?php
$rate = 1.18;
$prices = [10, 20, 30];

// Arrow function — no 'use' needed
$withTax = array_map(fn($p) => $p * $rate, $prices);

print_r($withTax); // [11.8, 23.6, 35.4]

Las funciones flecha no pueden modificar el ámbito externo

Las funciones flecha solo capturan por valor; no pueden modificar las variables externas:

<?php
$total = 0;
$nums  = [1, 2, 3];

// This does NOT modify $total!
array_walk($nums, fn($n) => $total += $n);

echo $total;  // 0

// Use a reference closure for mutation:
array_walk($nums, function($n) use (&$total) { $total += $n; });
echo $total;  // 6

Closures como callbacks

Muchas funciones de PHP aceptan un callable: puede pasar una closure, un array [$obj, 'method'] o el nombre de una función como cadena:

<?php
$words = ['banana', 'apple', 'cherry'];

usort($words, fn($a, $b) => strcmp($a, $b));

print_r($words); // ['apple', 'banana', 'cherry']

Closure invocada inmediatamente

Puede definir y llamar a una closure en la misma línea, lo que resulta útil para crear un ámbito aislado:

<?php
$result = (function(): int {
    $x = 10;
    $y = 20;
    return $x + $y;
})();

echo $result; // 30
// $x and $y are not in outer scope

Closure::bind y bindTo

Puede volver a vincular una closure al contexto de otro objeto mediante Closure::bind():

<?php
class Counter {
    private int $value = 0;
}

$increment = Closure::bind(function(int $by): void {
    $this->value += $by;
}, new Counter(), Counter::class);

// Now $increment has access to private $value

Comprobación rápida

¿Cuál de las siguientes es la diferencia principal entre una closure normal con use y una función flecha en PHP?

Repaso: funciones anónimas y closures

Resumen:

Las funciones anónimas se almacenan en variables y se pueden pasar como argumentos
Las closures capturan variables externas con use($var) (por valor) o use(&$var) (por referencia)
Las funciones flecha (PHP 7.4) capturan automáticamente el ámbito externo por valor
Son útiles para callbacks: array_map, usort, array_filter…
Se pueden devolver desde funciones de fábrica

Preguntas frecuentes

¿La lección «Funciones anónimas y closures» es gratis?

Sí — el texto completo de «Funciones anónimas y closures» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de PHP Academy, actualiza a CoddyKit PRO. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Funciones anónimas y closures»?

Escriba funciones inline y capture variables mediante use. Practicas PHP Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar PHP Academy?

No se requiere experiencia previa. PHP Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Funciones anónimas y closures»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de PHP Academy?

Sí. Cada lección de PHP Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a PHP Academy