PHP array_map(): Funktion auf jedes Element anwenden

array_map($callback, $array) ruft $callback für jedes Element von $array auf und liefert ein neues Array mit den Ergebnissen. Der Callback kommt zuerst, das Array an zweiter Stelle, und das ursprüngliche Array bleibt unverändert.

<?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 ist eine Arrow Function: eine Funktion aus einem einzigen Ausdruck, die ihr Ergebnis zurückgibt. Jedes Callable funktioniert an ihrer Stelle.

Eine eingebaute Funktion als Callback verwenden

Übergib den Namen einer eingebauten Funktion als String. So räumst du am kürzesten ein ganzes Array auf: jeden Wert trimmen, Strings in Ganzzahlen umwandeln oder die Schreibweise ändern.

<?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', ...) ist der übliche Weg, die Strings aus einem Formular oder aus explode() in echte Ganzzahlen umzuwandeln. Du kannst auch intval(...) schreiben, die First-Class-Callable-Syntax aus PHP 8.1, die dein Editor vervollständigen und prüfen kann.

Eine Closure mit äußeren Variablen verwenden

Eine Arrow Function sieht die Variablen um sie herum automatisch. Eine klassische function braucht use, um sie hereinzuholen. Beides wird auf der Seite zu anonymen Funktionen erklärt.

<?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 mit Schlüsseln

Bei einem einzelnen Array behält array_map die Schlüssel, auch String-Schlüssel. Aber der Callback bekommt nur den Wert. Um auch den Schlüssel zu bekommen, übergibst du array_keys($array) als zweites Array: Der Callback wird dann mit je einem Element aus jedem Array aufgerufen.

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

Beachte das zweite Ergebnis: Sobald du mehr als ein Array übergibst, werden die Schlüssel durch 0, 1, 2 ersetzt. Deshalb baut die letzte Zeile sie mit array_combine() wieder auf.

Mehrere Arrays auf einmal mappen

Jedes zusätzliche Array wird zu einem zusätzlichen Argument des Callbacks, nach Position zugeordnet. Haben die Arrays unterschiedliche Längen, werden die kürzeren mit null aufgefüllt.

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

Wenn du null als Callback übergibst, wird keine Funktion aufgerufen, und die Arrays werden zu Paaren zusammengefügt:

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

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

array_map vs array_walk vs foreach

array_map baut ein neues Array. array_walk ändert das übergebene Array über eine Referenz und gibt dem Callback den Schlüssel als zweites Argument. Ein foreach kann beides und kann außerdem Elemente überspringen oder mit break früh aufhören.

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

Verwende array_map, wenn aus jedem Element genau ein neues Element wird. Wenn du außerdem Elemente weglassen musst, kombinierst du es mit array_filter oder schreibst ein foreach.

Typischer Fehler: die Reihenfolge der Argumente

array_map nimmt zuerst den Callback und dann das Array. Sein Nachbar array_filter nimmt sie umgekehrt, und das verwechselt man leicht:

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

Vertauscht man sie, wirft PHP 8 einen TypeError, weil ein einfaches Array kein gültiger Callback ist:

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

PHP stoppt mit:

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

Vertausche die beiden Argumente wieder, und der Block läuft.