PHP array_map(): Apply a Function to Every Element

array_map($callback, $array) calls $callback on every element of $array and returns a new array with the results. The callback comes first, the array second, and the original array is left unchanged.

<?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 is an arrow function: a one-expression function that returns its result. Any callable works in its place.

Use a built-in function as the callback

Pass the name of a built-in function as a string. This is the shortest way to clean up a whole array: trim every value, convert strings to integers, or change case.

<?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', ...) is the usual way to turn the strings from a form or explode() into real integers. You can also write intval(...), the first-class callable syntax from PHP 8.1, which your editor can autocomplete and check.

Use a closure with outside variables

An arrow function sees the variables around it automatically. A classic function needs use to bring them in. Both are explained on the anonymous functions page.

<?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 with keys

With a single array, array_map keeps the keys, including string keys. But the callback only receives the value. To get the key too, pass array_keys($array) as a second array: the callback is then called with one element from each 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));

Notice the second result: as soon as you pass more than one array, the keys are replaced by 0, 1, 2. That is why the last line uses array_combine() to rebuild them.

Map multiple arrays at once

Every extra array becomes an extra argument to the callback, matched by position. If the arrays have different lengths, the shorter ones are padded with 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));

Passing null as the callback skips the function and zips the arrays into pairs:

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

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

array_map vs array_walk vs foreach

array_map builds a new array. array_walk changes the array you pass in, through a reference, and gives the callback the key as its second argument. A foreach does either and can also skip elements or stop early with 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);

Use array_map when every element turns into exactly one new element. If you also need to drop some elements, combine it with array_filter, or write a foreach.

Common mistake: the argument order

array_map takes the callback first and the array second. Its neighbour array_filter takes them the other way round, which is easy to mix up:

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

Swapping them makes PHP 8 throw a TypeError, because a plain array is not a valid callback:

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

PHP stops with:

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

Swap the two arguments back and the block runs.