Saltar al contenido principal
Representación visual de un array en PHP con funciones map, filter y reduce.

Domina los arrays en PHP: map, filter, reduce y más

#php #arrays #funciones

Los arrays son quizá la estructura de datos más usada en PHP. Desde listar productos de una tienda, filtrar resultados de una base de datos, ordenar usuarios o agrupar estadísticas, casi todo pasa por un array en algún momento.

En este post te voy a enseñar las funciones que más uso para transformar, filtrar, combinar y ordenar arrays, con ejemplos reales que puedes copiar y adaptar directamente a tus proyectos.

Transformar datos con array_map()

array_map() aplica una función a cada elemento de un array y devuelve un nuevo array con los resultados. Es ideal cuando necesitas transformar una colección sin modificar la original.

$precios = [100, 250, 80, 430];

$conIva = array_map(function ($precio) {
    return $precio * 1.16;
}, $precios);

print_r($conIva);
// [116, 290, 92.8, 498.8]

También puedes usar funciones con nombre o arrow functions de PHP 7.4+:

$nombres = ["juan", "maria", "pedro"];
$capitalizados = array_map('ucfirst', $nombres);

print_r($capitalizados);
// ["Juan", "Maria", "Pedro"]

Caso de uso real: Formatear una lista de precios para mostrar en una tabla.

$productos = [
    ['nombre' => 'Mouse', 'precio' => 350],
    ['nombre' => 'Teclado', 'precio' => 750],
    ['nombre' => 'Monitor', 'precio' => 3200],
];

$preciosFormateados = array_map(function ($producto) {
    return [
        'nombre' => $producto['nombre'],
        'precio' => '$' . number_format($producto['precio'], 2),
    ];
}, $productos);

Filtrar elementos con array_filter()

array_filter() devuelve un nuevo array con solo los elementos que cumplen una condición. La clave original se conserva, así que si necesitas índices consecutivos, recuerda usar array_values().

$numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

$pares = array_filter($numeros, function ($numero) {
    return $numero % 2 === 0;
});

print_r($pares);
// [1 => 2, 3 => 4, 5 => 6, 7 => 8, 9 => 10]

$pares = array_values($pares);
// [2, 4, 6, 8, 10]

Ejemplo práctico: Filtrar productos que tienen stock disponible.

$productos = [
    ['nombre' => 'Mouse', 'stock' => 12],
    ['nombre' => 'Teclado', 'stock' => 0],
    ['nombre' => 'Monitor', 'stock' => 3],
];

$disponibles = array_filter($productos, function ($producto) {
    return $producto['stock'] > 0;
});

Si omites la función de callback, array_filter() elimina los valores que son “falsos” (false, 0, "", null, []):

$valores = [0, 1, "", "hola", null, [], true];
$limpio = array_filter($valores);

print_r($limpio);
// [1 => 1, 3 => "hola", 6 => true]

Reducir arrays con array_reduce()

array_reduce() convierte un array en un único valor acumulado. Es perfecto para sumar totales, construir strings, contar elementos o transformar una lista en una estructura diferente.

$ventas = [120, 340, 560, 90];

$total = array_reduce($ventas, function ($acumulador, $venta) {
    return $acumulador + $venta;
}, 0);

echo $total; // 1110

Caso de uso real: Calcular el total de un carrito de compras con productos y cantidades.

$carrito = [
    ['producto' => 'Mouse', 'precio' => 350, 'cantidad' => 2],
    ['producto' => 'Teclado', 'precio' => 750, 'cantidad' => 1],
];

$total = array_reduce($carrito, function ($acumulador, $item) {
    return $acumulador + ($item['precio'] * $item['cantidad']);
}, 0);

echo $total; // 1450

También puedes usar array_reduce() para construir estructuras más complejas:

$usuarios = [
    ['nombre' => 'Ana', 'rol' => 'admin'],
    ['nombre' => 'Luis', 'rol' => 'editor'],
    ['nombre' => 'Sofía', 'rol' => 'admin'],
];

$porRol = array_reduce($usuarios, function ($acumulador, $usuario) {
    $acumulador[$usuario['rol']][] = $usuario['nombre'];
    return $acumulador;
}, []);

print_r($porRol);
// [
//   "admin" => ["Ana", "Sofía"],
//   "editor" => ["Luis"]
// ]

Combinar arrays con array_merge()

array_merge() une dos o más arrays en uno solo. Si las claves son numéricas, se reindexan automáticamente. Si son strings, los valores posteriores sobrescriben a los anteriores.

$frutas = ["manzana", "pera"];
$verduras = ["zanahoria", "espinaca"];

$alimentos = array_merge($frutas, $verduras);

print_r($alimentos);
// ["manzana", "pera", "zanahoria", "espinaca"]

Ejemplo práctico: Unir configuraciones por defecto con configuraciones personalizadas del usuario.

$defaultConfig = [
    'theme' => 'light',
    'lang' => 'es',
    'notifications' => true,
];

$userConfig = [
    'theme' => 'dark',
    'lang' => 'en',
];

$config = array_merge($defaultConfig, $userConfig);

print_r($config);
// ['theme' => 'dark', 'lang' => 'en', 'notifications' => true]

Eliminar duplicados con array_unique()

array_unique() elimina los valores duplicados de un array, conservando la primera aparición de cada valor.

$tags = ["php", "mysql", "php", "linux", "mysql", "bash"];

$tagsUnicos = array_unique($tags);

print_r($tagsUnicos);
// ["php", "mysql", "linux", "bash"]

Caso real: Limpiar una lista de correos antes de enviar una newsletter.

$emails = [
    "juan@email.com",
    "maria@email.com",
    "juan@email.com",
    "pedro@email.com",
];

$emailsUnicos = array_values(array_unique($emails));
// ["juan@email.com", "maria@email.com", "pedro@email.com"]

Ordenar arrays con sort() y usort()

PHP ofrece muchas funciones para ordenar arrays. Las más comunes son:

  • sort() - Ordena un array indexado de menor a mayor.
  • rsort() - Ordena un array indexado de mayor a menor.
  • asort() / arsort() - Ordenan arrays asociativos preservando las claves.
  • ksort() / krsort() - Ordenan arrays asociativos por sus claves.
  • usort() - Ordena con una función de comparación personalizada.
$numeros = [5, 2, 8, 1, 9];
sort($numeros);

print_r($numeros);
// [1, 2, 5, 8, 9]

Ejemplo con array asociativo:

$usuarios = [
    ['nombre' => 'Carlos', 'edad' => 30],
    ['nombre' => 'Ana', 'edad' => 25],
    ['nombre' => 'Luis', 'edad' => 35],
];

usort($usuarios, function ($a, $b) {
    return $a['edad'] <=> $b['edad'];
});

print_r($usuarios);
// Ana (25), Carlos (30), Luis (35)

El operador spaceship <=> compara dos valores y devuelve -1, 0 o 1, lo que hace que usort() sea muy limpio de leer.

Combinando funciones: el poder real

La verdadera potencia de estas funciones aparece cuando las combinas. Imagina que tienes una lista de productos y necesitas filtrar los disponibles, calcular el total con IVA y formatear el resultado.

$productos = [
    ['nombre' => 'Mouse', 'precio' => 350, 'stock' => 12],
    ['nombre' => 'Teclado', 'precio' => 750, 'stock' => 0],
    ['nombre' => 'Monitor', 'precio' => 3200, 'stock' => 3],
    ['nombre' => 'Webcam', 'precio' => 1200, 'stock' => 8],
];

$totalConIva = array_reduce(
    array_filter($productos, fn($p) => $p['stock'] > 0),
    fn($total, $p) => $total + ($p['precio'] * 1.16),
    0
);

echo number_format($totalConIva, 2);
// 5559.00

Otro patrón común: obtener una lista limpia de valores únicos a partir de datos crudos.

$registros = [
    ['ciudad' => 'CDMX', 'venta' => 100],
    ['ciudad' => 'Guadalajara', 'venta' => 200],
    ['ciudad' => 'CDMX', 'venta' => 150],
];

$ciudades = array_values(array_unique(array_map(
    fn($r) => $r['ciudad'],
    $registros
)));

print_r($ciudades);
// ["CDMX", "Guadalajara"]

Funciones adicionales útiles

Estas no las cubrimos en detalle pero vale la pena conocerlas:

  • array_column() - Extrae una sola columna de un array multidimensional.
  • array_search() - Busca un valor y devuelve su clave.
  • in_array() - Verifica si un valor existe en un array.
  • array_key_exists() - Verifica si una clave existe.
  • array_slice() - Extrae una porción de un array.
  • array_splice() - Elimina o reemplaza una porción de un array.
  • array_chunk() - Divide un array en fragmentos más pequeños.
$usuarios = [
    ['id' => 1, 'nombre' => 'Ana'],
    ['id' => 2, 'nombre' => 'Luis'],
];

$nombres = array_column($usuarios, 'nombre');
// ["Ana", "Luis"]

$ids = array_column($usuarios, 'id', 'nombre');
// ["Ana" => 1, "Luis" => 2]

Conclusión

Dominar estas funciones te permite escribir código PHP más limpio, declarativo y fácil de mantener. En lugar de llenar tu código con bucles foreach anidados, puedes expresar la intención de tu lógica de forma clara con map, filter y reduce.

Mi recomendación: identifica en tu proyecto actual dónde estás transformando, filtrando o reduciendo listas y reemplaza esos bloques con las funciones adecuadas. Con la práctica, empezarás a ver patrones de procesamiento de datos de forma natural.

¡Espero que estos ejemplos te sean útiles para tu próximo proyecto PHP!