array_map

(PHP 4 >= 4.0.6, PHP 5, PHP 7)

array_map — Stosuje podany callback do elementów podanych tablic

Opis

array_map ( callable $callback , array $array1 [, array $... ] ) : array

array_map() zwraca tablicę zawierającą wszystkie elementy array1 po wykonaniu funkcji callback na każdym z nich. Liczba parametrów przyjmowanych przez callback powinna wynosić tyle, ile tablic przekazano do array_map()

Parametry

callback: Funkcja zwrotna do wykonania na każdym elemencie każdej tablicy.
array1: Tablica do przepuszczenia przez podany callback.
...: Dalsza lista tablic do przepuszczenia przez funkcję podaną w argumencie callback.

Zwracane wartości

Zwraca tablicę zawierającą wszystkie elementy array1 po wykonaniu funkcji callback na każdym z nich.

Przykłady

Przykład #1 Przykład użycia array_map()


<?php
function cube($n)
{
    return($n * $n * $n);
}

$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);
?>

Zmienna b $b otrzyma:

Array
(
    [0] => 1
    [1] => 8
    [2] => 27
    [3] => 64
    [4] => 125
)

Przykład #2 array_map() z użyciem funkcji anonimowej (od PHP 5.3.0)


<?php
$func = function($value) {
    return $value * 2;
};

print_r(array_map($func, range(1, 5)));
?>

Array
(
    [0] => 2
    [1] => 4
    [2] => 6
    [3] => 8
    [4] => 10
)

Przykład #3 array_map() - większa ilość tablic


<?php
function show_Spanish($n, $m)
{
    return("Cyfra $n to po hiszpańsku $m");
}

function map_Spanish($n, $m)
{
    return(array($n => $m));
}

$a = array(1, 2, 3, 4, 5);
$b = array("uno", "dos", "tres", "cuatro", "cinco");

$c = array_map("show_Spanish", $a, $b);
print_r($c);

$d = array_map("map_Spanish", $a , $b);
print_r($d);
?>

Powyższy przykład wyświetli:

// printout of $c
Array
(
    [0] => Cyfra 1 to po hiszpańsku uno
    [1] => Cyfra 2 to po hiszpańsku dos
    [2] => Cyfra 3 to po hiszpańsku tres
    [3] => Cyfra 4 to po hiszpańsku cuatro
    [4] => Cyfra 5 to po hiszpańsku cinco
)

// wypis zmiennej $d
Array
(
    [0] => Array
        (
            [1] => uno
        )

    [1] => Array
        (
            [2] => dos
        )

    [2] => Array
        (
            [3] => tres
        )

    [3] => Array
        (
            [4] => cuatro
        )

    [4] => Array
        (
            [5] => cinco
        )

)

Zazwyczaj, gdy używa się dwóch lub więcej tablic, powinny one mieć jednakową długość, ponieważ funkcja zwrotna jest stosowana równolegle do odpowiadających elementów. Jeśli tablice nie są równej długości, krótsze zostaną rozszerzone używając pustych elementów, tak aby ich długość zgadzała się z najdłuższą z tablic.

Ciekawym zastosowaniem tej funkcji może być kontrurowanie tablicy tablic, które może zostać łatwo osiągnięte dzięki użyciu NULL jako nazwy funkcji zwrotnej

Przykład #4 Tworzenie tablicy tablic


<?php
$a = array(1, 2, 3, 4, 5);
$b = array("one", "two", "three", "four", "five");
$c = array("uno", "dos", "tres", "cuatro", "cinco");

$d = array_map(null, $a, $b, $c);
print_r($d);
?>

Powyższy przykład wyświetli:

Array
(
    [0] => Array
        (
            [0] => 1
            [1] => one
            [2] => uno
        )

    [1] => Array
        (
            [0] => 2
            [1] => two
            [2] => dos
        )

    [2] => Array
        (
            [0] => 3
            [1] => three
            [2] => tres
        )

    [3] => Array
        (
            [0] => 4
            [1] => four
            [2] => cuatro
        )

    [4] => Array
        (
            [0] => 5
            [1] => five
            [2] => cinco
        )

)

Zwracana tablica zachowa klucze tablicy podanej jako argument jeśli i tylko jeśli przekazany zostanie dokładnie jedna tablica. Jeśli zostanie przekazana więcej niż jedna tablica, zwrócona tablica otrzyma kolejne klucze numeryczne.

Przykład #5 array_map() - z kluczami tekstowymi


<?php
$arr = array("nazwa" => "wartość");
function cb1($a) {
    return array ($a);
}
function cb2($a, $b) {
    return array ($a, $b);
}
var_dump(array_map("cb1", $arr));
var_dump(array_map("cb2", $arr, $arr));
var_dump(array_map(null,  $arr));
var_dump(array_map(null, $arr, $arr));
?>

Powyższy przykład wyświetli:

array(1) {
  ["nazwa"]=>
  array(1) {
    [0]=>
    string(5) "wartość"
  }
}
array(1) {
  [0]=>
  array(2) {
    [0]=>
    string(5) "wartość"
    [1]=>
    string(5) "wartość"
  }
}
array(1) {
  ["nazwa"]=>
  string(5) "wartość"
}
array(1) {
  [0]=>
  array(2) {
    [0]=>
    string(5) "wartość"
    [1]=>
    string(5) "wartość"
  }
}

Zobacz też:

array_filter() - Filtruje elementy przy użyciu callbacku
array_reduce() - Iteracyjnie zredukuj tablicę do pojedyńczej wartości używając funkcji zwrotnej
array_walk() - Zastosuj funkcję użytkownika do każdego elementu tablicy
informacje o typie callback

add a note

User Contributed Notes 6 notes

down

lukasz dot mordawski at gmail dot com ¶

10 years ago


Let's assume we have following situation:

<?php
class MyFilterClass {
    public function filter(array $arr) {
        return array_map(function($value) {
            return $this->privateFilterMethod($value);
        });
    }

    private function privateFilterMethod($value) {
        if (is_numeric($value)) $value++;
        else $value .= '.';
    }
}
?>

This will work, because $this inside anonymous function (unlike for example javascript) is the instance of MyFilterClass inside which we called it.
I hope this would be useful for anyone.

down

elfe1021 at gmail dot com ¶

10 years ago


Find an interesting thing that in array_map's callable function, late static binding does not work:
<?php
class A {
    public static function foo($name) {
        return 'In A: '.$name;
    }

    public static function test($names) {
        return array_map(function($n) {return static::foo($n);}, $names);
    }
}

class B extends A{
    public static function foo($name) {
        return 'In B: '.$name;
    }
}

$result = B::test(['alice', 'bob']);
var_dump($result);
?>

the result is:
array (size=2)
  0 => string 'In A: alice' (length=11)
  1 => string 'In A: bob' (length=9)

if I change A::test to
<?php
    public static function test($names) {
        return array_map([get_called_class(), 'foo'], $names);
    }
?>

Then the result is as expected:
array (size=2)
  0 => string 'In B: alice' (length=11)
  1 => string 'In B: bob' (length=9)

down

Mahn ¶

8 years ago


You may be looking for a method to extract values of a multidimensional array on a conditional basis (i.e. a mixture between array_map and array_filter) other than a for/foreach loop. If so, you can take advantage of the fact that 1) the callback method on array_map returns null if no explicit return value is specified (as with everything else) and 2) array_filter with no arguments removes falsy values. 

So for example, provided you have:

<?php
$data = [
    [
        "name" => "John",
        "smoker" => false
    ],
    [
        "name" => "Mary",
        "smoker" => true
    ],
    [
        "name" => "Peter",
        "smoker" => false
    ],
    [
        "name" => "Tony",
        "smoker" => true
    ]
];
?>

You can extract the names of all the non-smokers with the following one-liner:

<?php
$names = array_filter(array_map(function($n) { if(!$n['smoker']) return $n['name']; }, $data));
?>

It's not necessarily better than a for/foreach loop, but the occasional one-liner for trivial tasks can help keep your code cleaner.

down

radist-hack at yandex dot ru ¶

15 years ago


To transpose rectangular two-dimension array, use the following code:

array_unshift($array, null);
$array = call_user_func_array("array_map", $array);

If you need to rotate rectangular two-dimension array on 90 degree, add the following line before or after (depending on the rotation direction you need) the code above:
$array = array_reverse($array);

Here is example:

<?php
$a = array(
  array(1, 2, 3),
  array(4, 5, 6));
array_unshift($a, null);
$a = call_user_func_array("array_map", $a);
print_r($a);
?>

Output:

Array
(
    [0] => Array
        (
            [0] => 1
            [1] => 4
        )

    [1] => Array
        (
            [0] => 2
            [1] => 5
        )

    [2] => Array
        (
            [0] => 3
            [1] => 6
        )

)

down

stijnleenknegt at gmail dot com ¶

15 years ago


If you want to pass an argument like ENT_QUOTES to htmlentities, you can do the follow.

<?php
$array = array_map( 'htmlentities' , $array, array_fill(0 , count($array) , ENT_QUOTES) );
?>

The third argument creates an equal sized array of $array filled with the parameter you want to give with your callback function.

down

CertaiN ¶

10 years ago


The most memory-efficient array_map_recursive().

<?php
function array_map_recursive(callable $func, array $arr) {
    array_walk_recursive($arr, function(&$v) use ($func) {
        $v = $func($v);
    });
    return $arr;
}
?>

add a note