PHP array_map(): aplicar una función a cada elemento

array_map($callback, $array) llama a $callback con cada elemento de $array y devuelve un array nuevo con los resultados. Primero va el callback y después el array, y el array original no se modifica.

<?php
$prices = [10, 25, 40];

$withTax = array_map(fn($p) => $p * 1.2, $prices);

print_r($withTax);
print_r($prices); // unchanged

fn($p) => $p * 1.2 es una función flecha: una función de una sola expresión que devuelve su resultado. En su lugar sirve cualquier callable.

Usar una función nativa como callback

Pasa el nombre de una función nativa como cadena. Es la forma más corta de limpiar un array entero: recortar cada valor, convertir cadenas en enteros o cambiar mayúsculas y minúsculas.

<?php
$raw = ["  apple ", "Banana  ", " cherry"];
print_r(array_map('trim', $raw));

$ids = ["4", "15", "42"];
var_dump(array_map('intval', $ids));

$names = ["ada", "grace", "linus"];
print_r(array_map('ucfirst', $names));

array_map('intval', ...) es la forma habitual de convertir en enteros de verdad las cadenas que llegan de un formulario o de explode(). También puedes escribir intval(...), la sintaxis de callable de primera clase de PHP 8.1, que tu editor puede autocompletar y comprobar.

Usar un closure con variables de fuera

Una función flecha ve automáticamente las variables que la rodean. Una function clásica necesita use para traerlas. Las dos se explican en la página de funciones anónimas.

<?php
$rate = 0.15;
$amounts = [100, 250, 80];

// Arrow function: $rate is captured automatically
$tips = array_map(fn($a) => round($a * $rate, 2), $amounts);
print_r($tips);

// Classic closure: $rate must be listed in use()
$tips2 = array_map(function ($a) use ($rate) {
    return round($a * $rate, 2);
}, $amounts);
print_r($tips2);

array_map con claves

Con un solo array, array_map conserva las claves, incluidas las de texto. Pero el callback solo recibe el valor. Para obtener también la clave, pasa array_keys($array) como segundo array: el callback se llama entonces con un elemento de cada array.

<?php
$stock = ["apples" => 12, "pears" => 0, "plums" => 7];

// Keys are kept
print_r(array_map(fn($n) => $n * 2, $stock));

// Key and value in the callback
$lines = array_map(
    fn($name, $count) => "$name: $count",
    array_keys($stock),
    $stock
);
print_r($lines);

// Same, with the original keys put back
print_r(array_combine(array_keys($stock), $lines));

Fíjate en el segundo resultado: en cuanto pasas más de un array, las claves se sustituyen por 0, 1, 2. Por eso la última línea usa array_combine() para reconstruirlas.

Mapear varios arrays a la vez

Cada array extra se convierte en un argumento extra del callback, emparejado por posición. Si los arrays tienen longitudes distintas, los más cortos se rellenan con null.

<?php
$first = ["Ada", "Grace", "Linus"];
$last  = ["Lovelace", "Hopper", "Torvalds"];

print_r(array_map(fn($f, $l) => "$f $l", $first, $last));

// Different lengths: missing values arrive as null
$a = [1, 2, 3];
$b = [10, 20];
print_r(array_map(fn($x, $y) => $x + ($y ?? 0), $a, $b));

Pasar null como callback se salta la función y empareja los arrays en parejas:

<?php
$names = ["Ada", "Grace"];
$years = [1815, 1906];

print_r(array_map(null, $names, $years));

array_map vs array_walk vs foreach

array_map construye un array nuevo. array_walk cambia el array que le pasas, mediante una referencia, y le da al callback la clave como segundo argumento. Un foreach hace cualquiera de las dos cosas y además puede saltarse elementos o parar antes con break.

<?php
$tags = [" php ", " arrays", "map "];

// New array, input untouched
$clean = array_map('trim', $tags);

// Change in place: note the & before $value
array_walk($tags, function (&$value, $key) {
    $value = "#$key " . trim($value);
});

print_r($clean);
print_r($tags);

Usa array_map cuando cada elemento se convierte exactamente en un elemento nuevo. Si además necesitas descartar algunos elementos, combínalo con array_filter, o escribe un foreach.

Error frecuente: el orden de los argumentos

array_map recibe primero el callback y después el array. Su vecina array_filter los recibe al revés, y es fácil confundirlas:

array_map($callback, $array);     // callback first
array_filter($array, $callback);  // array first

Si los intercambias, PHP 8 lanza un TypeError, porque un array normal no es un callback válido:

<?php
// This throws a TypeError on purpose: the arguments are swapped
$numbers = [1, 2, 3];
$doubled = array_map($numbers, fn($n) => $n * 2);

PHP se detiene con:

PHP Fatal error:  Uncaught TypeError: array_map(): Argument #1 ($callback) must be a valid callback or null, array callback must have exactly two members in /home/index.php:4

Vuelve a poner los dos argumentos en su orden y el bloque funciona.