array_map() w PHP: funkcja na każdym elemencie tablicy

array_map($callback, $array) wywołuje $callback na każdym elemencie $array i zwraca nową tablicę z wynikami. Najpierw callback, potem tablica, a oryginalna tablica pozostaje bez zmian.

<?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 to funkcja strzałkowa: funkcja z jednym wyrażeniem, która zwraca jego wynik. W jej miejscu zadziała dowolny callable.

Funkcja wbudowana jako callback

Przekaż nazwę funkcji wbudowanej jako string. To najkrótszy sposób na uporządkowanie całej tablicy: przytnij każdą wartość, zamień stringi na liczby całkowite albo zmień wielkość liter.

<?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', ...) to zwykły sposób na zamianę stringów z formularza lub z explode() w prawdziwe liczby całkowite. Możesz też napisać intval(...), składnię first-class callable z PHP 8.1, którą twój edytor potrafi podpowiedzieć i sprawdzić.

Domknięcie ze zmiennymi z zewnątrz

Funkcja strzałkowa automatycznie widzi otaczające ją zmienne. Klasyczne function potrzebuje use, aby je wciągnąć. Oba rodzaje wyjaśnia strona o funkcjach anonimowych.

<?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 z kluczami

Przy jednej tablicy array_map zachowuje klucze, także tekstowe. Callback dostaje jednak tylko wartość. Aby dostać też klucz, przekaż array_keys($array) jako drugą tablicę: callback jest wtedy wywoływany z jednym elementem z każdej tablicy.

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

Zwróć uwagę na drugi wynik: gdy tylko przekażesz więcej niż jedną tablicę, klucze są zastępowane przez 0, 1, 2. Dlatego ostatnia linia odbudowuje je przez array_combine().

Mapowanie kilku tablic naraz

Każda dodatkowa tablica staje się dodatkowym argumentem callbacku, dopasowanym po pozycji. Jeśli tablice mają różne długości, krótsze są uzupełniane wartością 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));

Przekazanie null jako callbacku pomija funkcję i łączy tablice w pary:

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

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

array_map vs array_walk vs foreach

array_map buduje nową tablicę. array_walk zmienia przekazaną tablicę przez referencję i podaje callbackowi klucz jako drugi argument. foreach potrafi jedno i drugie, a do tego może pomijać elementy lub zakończyć się wcześniej przez 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);

Używaj array_map, gdy każdy element zamienia się w dokładnie jeden nowy element. Jeśli musisz też odrzucić część elementów, połącz go z array_filter albo napisz foreach.

Częsty błąd: kolejność argumentów

array_map przyjmuje najpierw callback, a potem tablicę. Sąsiednia array_filter przyjmuje je odwrotnie, co łatwo pomylić:

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

Zamiana sprawia, że PHP 8 rzuca TypeError, bo zwykła tablica nie jest poprawnym callbackiem:

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

PHP zatrzymuje się z komunikatem:

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

Zamień argumenty z powrotem, a blok się wykona.