PHP array_map() : appliquer une fonction à chaque élément

array_map($callback, $array) appelle $callback sur chaque élément de $array et renvoie un nouveau tableau avec les résultats. Le callback vient en premier, le tableau en second, et le tableau d'origine n'est pas modifié.

<?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 est une fonction fléchée : une fonction d'une seule expression qui renvoie son résultat. N'importe quel callable fonctionne à sa place.

Utiliser une fonction native comme callback

Passez le nom d'une fonction native sous forme de chaîne. C'est la façon la plus courte de nettoyer tout un tableau : appliquer trim à chaque valeur, convertir des chaînes en entiers ou changer la casse.

<?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', ...) est la façon habituelle de transformer les chaînes d'un formulaire ou d'explode() en vrais entiers. Vous pouvez aussi écrire intval(...), la syntaxe de callable de première classe de PHP 8.1, que votre éditeur peut compléter et vérifier.

Utiliser une closure avec des variables extérieures

Une fonction fléchée voit automatiquement les variables qui l'entourent. Une function classique a besoin de use pour les importer. Les deux sont expliquées sur la page des fonctions anonymes.

<?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 avec les clés

Avec un seul tableau, array_map garde les clés, y compris les clés de type chaîne. Mais le callback ne reçoit que la valeur. Pour obtenir aussi la clé, passez array_keys($array) comme second tableau : le callback est alors appelé avec un élément de chaque tableau.

<?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));

Remarquez le second résultat : dès que vous passez plus d'un tableau, les clés sont remplacées par 0, 1, 2. C'est pourquoi la dernière ligne utilise array_combine() pour les reconstruire.

Mapper plusieurs tableaux à la fois

Chaque tableau supplémentaire devient un argument supplémentaire du callback, associé par position. Si les tableaux n'ont pas la même longueur, les plus courts sont complétés par 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));

Passer null comme callback saute la fonction et assemble les tableaux par paires :

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

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

array_map, array_walk ou foreach

array_map construit un nouveau tableau. array_walk modifie le tableau que vous passez, via une référence, et donne la clé au callback en second argument. Un foreach fait l'un ou l'autre et peut aussi sauter des éléments ou s'arrêter tôt avec 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);

Utilisez array_map quand chaque élément devient exactement un nouvel élément. Si vous devez aussi écarter certains éléments, combinez-la avec array_filter, ou écrivez un foreach.

Erreur fréquente : l'ordre des arguments

array_map prend le callback en premier et le tableau en second. Sa voisine array_filter les prend dans l'autre ordre, ce qui se confond facilement :

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

Les inverser fait lever une TypeError à PHP 8, car un simple tableau n'est pas un callback valide :

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

PHP s'arrête avec :

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

Remettez les deux arguments dans l'ordre et le bloc s'exécute.