La programación funcional no es exclusiva de lenguajes como Haskell, Elixir o Scala. PHP también permite adoptar muchos de sus principios para escribir código más limpio, expresivo y fácil de mantener.
Veamos algunas de las herramientas que ofrece PHP.
Funciones como ciudadanos de primera clase
Las funciones pueden almacenarse en variables, pasarse como argumentos y devolverse desde otras funciones.
<?php
$greet = fn(string $name) => "Hello $name!";
echo $greet("Emanuel");
Salida:
Hello Emanuel!
Arrow Functions
Introducidas en PHP 7.4, las Arrow Functions permiten escribir funciones pequeñas de manera mucho más concisa.
$numbers = [1, 2, 3, 4];
$squares = array_map(
fn($n) => $n * $n,
$numbers
);
print_r($squares);
Resultado:
Array
(
[0] => 1
[1] => 4
[2] => 9
[3] => 16
)
map()
Aunque PHP no posee un método map() sobre los arrays, dispone de array_map().
$names = ["john", "mary", "alice"];
$upper = array_map(
"strtoupper",
$names
);
print_r($upper);
Resultado:
JOHN
MARY
ALICE
filter()
Para filtrar colecciones se utiliza `array_filter()`.
$numbers = [1,2,3,4,5,6];
$even = array_filter(
$numbers,
fn($n) => $n % 2 === 0
);
print_r($even);
Resultado:
2
4
6
reduce()
array_reduce() permite reducir una colección a un único valor.
$numbers = [1,2,3,4,5];
$sum = array_reduce(
$numbers,
fn($acc, $n) => $acc + $n,
0
);
echo $sum;
Resultado
15
Funciones puras
Una función pura siempre devuelve el mismo resultado para la misma entrada y no produce efectos secundarios.
function add(int $a, int $b): int
{
return $a + $b;
}
En cambio, esta función no es pura:
$total = 0;
function addToTotal(int $n): void
{
global $total;
$total += $n;
}
Inmutabilidad
PHP no posee estructuras inmutables por defecto, pero es posible trabajar evitando modificar los datos originales.
$numbers = [1,2,3];
$newNumbers = [...$numbers, 4];
print_r($numbers);
print_r($newNumbers);
Resultado:
Original:
1 2 3
Nuevo:
1 2 3 4
Composición de funciones
Podemos construir funciones más complejas combinando funciones pequeñas.
$trim = fn($s) => trim($s);
$upper = fn($s) => strtoupper($s);
$normalize = fn($s) => $upper($trim($s));
echo $normalize(" hello ");
Resultado
HELLO
Closures
Las closures permiten capturar variables del contexto.
function multiplier(int $factor)
{
return fn($n) => $n * $factor;
}
$double = multiplier(2);
$triple = multiplier(3);
echo $double(10);
echo $triple(10);
Resultado
20
30
Encadenando operaciones
Una secuencia típica de programación funcional consiste en filtrar, transformar y reducir datos.
$numbers = [1,2,3,4,5,6];
$result = array_reduce(
array_map(
fn($n) => $n * $n,
array_filter(
$numbers,
fn($n) => $n % 2 === 0
)
),
fn($acc, $n) => $acc + $n,
0
);
echo $result;
Proceso:
- Filtra los números pares.
- Calcula el cuadrado de cada uno.
- Suma todos los cuadrados.
Resultado:
56
Aunque PHP sigue siendo un lenguaje predominantemente orientado a objetos, incorpora suficientes herramientas para adoptar un estilo funcional cuando resulta conveniente. El uso de funciones puras, array_map(), array_filter(), array_reduce(), closures y Arrow Functions permite escribir código más declarativo, reutilizable y sencillo de razonar.
No reemplaza a lenguajes puramente funcionales como Haskell o Elixir, pero demuestra que la programación funcional es un paradigma que puede aplicarse con éxito en prácticamente cualquier lenguaje moderno.
