PHP array_map(): applicare una funzione a ogni elemento

array_map($callback, $array) chiama $callback su ogni elemento di $array e restituisce un nuovo array con i risultati. Prima la callback, poi l'array, e l'array originale resta invariato.

<?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 è una arrow function: una funzione di una sola espressione che restituisce il suo risultato. Al suo posto funziona qualsiasi callable.

Usare una funzione predefinita come callback

Passa il nome di una funzione predefinita come stringa. È il modo più breve per ripulire un intero array: applicare trim a ogni valore, convertire stringhe in interi o cambiare maiuscole e minuscole.

<?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', ...) è il modo consueto per trasformare in veri interi le stringhe arrivate da un form o da explode(). Puoi anche scrivere intval(...), la sintassi first-class callable di PHP 8.1, che il tuo editor può completare e controllare.

Usare una closure con variabili esterne

Una arrow function vede automaticamente le variabili intorno a sé. Una function classica ha bisogno di use per portarle dentro. Entrambe sono spiegate nella pagina sulle funzioni anonime.

<?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 le chiavi

Con un solo array, array_map mantiene le chiavi, comprese quelle stringa. Ma la callback riceve solo il valore. Per avere anche la chiave, passa array_keys($array) come secondo array: la callback viene allora chiamata con un elemento di ciascun 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));

Nota il secondo risultato: appena passi più di un array, le chiavi vengono sostituite da 0, 1, 2. Ecco perché l'ultima riga usa array_combine() per ricostruirle.

Map di più array insieme

Ogni array in più diventa un argomento in più per la callback, abbinato per posizione. Se gli array hanno lunghezze diverse, quelli più corti vengono completati 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));

Passare null come callback salta la funzione e accoppia gli array:

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

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

array_map vs array_walk vs foreach

array_map costruisce un nuovo array. array_walk modifica l'array che gli passi, tramite un riferimento, e dà alla callback la chiave come secondo argomento. Un foreach fa l'una o l'altra cosa e può anche saltare elementi o fermarsi prima 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 quando ogni elemento diventa esattamente un nuovo elemento. Se devi anche scartare alcuni elementi, combinala con array_filter, oppure scrivi un foreach.

Errore comune: l'ordine degli argomenti

array_map accetta prima la callback e poi l'array. La sua vicina array_filter li accetta al contrario, ed è facile confonderle:

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

Scambiarli fa lanciare a PHP 8 un TypeError, perché un semplice array non è una callback valida:

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

PHP si ferma 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

Rimetti i due argomenti nell'ordine giusto e il blocco viene eseguito.