(PHP 4 >= 4.0.6, PHP 5, PHP 7, PHP 8)
array_map —Applies the callback to the elements of the given arrays
array_map() returns anarray containing the results of applying thecallback to the corresponding value ofarray (andarrays if more arrays are provided) used as arguments for the callback. The number of parameters that thecallback function accepts should match the number of arrays passed toarray_map(). Excess input arrays are ignored. AnArgumentCountError is thrown if an insufficient number of arguments is provided.
callbackAcallable to run for each element in each array.
null can be passed as a value tocallback to perform a zip operation on multiple arrays and return an array whose elements are each an array holding the elements of the input arrays of the same index (see example below). If onlyarray is provided,array_map() will return the input array.
array An array to run through thecallback function.
arrays Supplementary variable list of array arguments to run through thecallback function.
Returns an array containing the results of applying thecallback function to the corresponding value ofarray (andarrays if more arrays are provided) used as arguments for the callback.
The returned array will preserve the keys of the array argument if and only if exactly one array is passed. If more than one array is passed, the returned array will have sequential integer keys.
| Version | Description |
|---|---|
| 8.0.0 | Ifcallback expects a parameter to be passed by reference, this function will now emit anE_WARNING. |
Example #1array_map() example
<?php
functioncube($n)
{
return ($n*$n*$n);
}
$a= [1,2,3,4,5];
$b=array_map('cube',$a);
print_r($b);
?>This makes$b have:
Array( [0] => 1 [1] => 8 [2] => 27 [3] => 64 [4] => 125)
Example #2array_map() using a lambda function
<?php
$func= function(int $value):int{
return$value*2;
};
print_r(array_map($func,range(1,5)));
// Or as of PHP 7.4.0:
print_r(array_map(fn($value):int=>$value*2,range(1,5)));
?>The above example will output:
Array( [0] => 2 [1] => 4 [2] => 6 [3] => 8 [4] => 10)
Example #3array_map() - using more arrays
<?php
functionshow_Spanish(int $n,string $m):string
{
return"The number{$n} is called{$m} in Spanish";
}
functionmap_Spanish(int $n,string $m): array
{
return [$n=>$m];
}
$a= [1,2,3,4,5];
$b= ['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);
?>The above example will output:
// printout of $cArray( [0] => The number 1 is called uno in Spanish [1] => The number 2 is called dos in Spanish [2] => The number 3 is called tres in Spanish [3] => The number 4 is called cuatro in Spanish [4] => The number 5 is called cinco in Spanish)// printout of $dArray( [0] => Array ( [1] => uno ) [1] => Array ( [2] => dos ) [2] => Array ( [3] => tres ) [3] => Array ( [4] => cuatro ) [4] => Array ( [5] => cinco ))
Usually when using two or more arrays, they should be of equal length because the callback function is applied in parallel to the corresponding elements. If the arrays are of unequal length, shorter ones will be extended with empty elements to match the length of the longest.
An interesting use of this function is to construct an array of arrays, which can be easily performed by usingnull as the name of the callback function
Example #4 Performing a zip operation of arrays
<?php
$a= [1,2,3,4,5];
$b= ['one','two','three','four','five'];
$c= ['uno','dos','tres','cuatro','cinco'];
$d=array_map(null,$a,$b,$c);
print_r($d);
?>The above example will output:
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 ))
Example #5nullcallback with onlyarray
<?php
$array= [1,2,3];
var_dump(array_map(null,$array));
?>The above example will output:
array(3) { [0]=> int(1) [1]=> int(2) [2]=> int(3)}Example #6array_map() - with string keys
<?php
$arr= ['stringkey'=>'value'];
functioncb1($a) {
return [$a];
}
functioncb2($a,$b) {
return [$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));
?>The above example will output:
array(1) { ["stringkey"]=> array(1) { [0]=> string(5) "value" }}array(1) { [0]=> array(2) { [0]=> string(5) "value" [1]=> string(5) "value" }}array(1) { ["stringkey"]=> string(5) "value"}array(1) { [0]=> array(2) { [0]=> string(5) "value" [1]=> string(5) "value" }}Example #7array_map() - associative arrays
Whilearray_map() does not directly support using the array key as an input, that may be simulated usingarray_keys().
<?php
$arr= [
'v1'=>'First release',
'v2'=>'Second release',
'v3'=>'Third release',
];
// Note: Before 7.4.0, use the longer syntax for anonymous functions instead.
$callback= fn(string $k,string $v):string=>"$k was the$v";
$result=array_map($callback,array_keys($arr),array_values($arr));
var_dump($result);
?>The above example will output:
array(3) { [0]=> string(24) "v1 was the First release" [1]=> string(25) "v2 was the Second release" [2]=> string(24) "v3 was the Third release"}Let's assume we have following situation:
<?php
classMyFilterClass{
public functionfilter(array$arr) {
returnarray_map(function($value) {
return$this->privateFilterMethod($value);
});
}
private functionprivateFilterMethod($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.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
)
)If the callback function to be called is a static method from a different namespace, the fully qualified method including namespace must be specified (a use statement is not sufficient to resolve the namespace of the callback function)
<?php
useMyTools;
$arr= [1,2,3];
$arr=array_map('Tools::myHelper',$arr);
?>
will cause TypeError:
array_map() expects parameter 1 to be a valid callback, class 'Tools' not found.
Use the fully qualified name for the callback instead:
<?php
$arr= [1,2,3];
$arr=array_map('\MyTools\Tools::myHelper',$arr);
?>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.The most memory-efficient array_map_recursive().
<?php
functionarray_map_recursive(callable$func, array$arr) {
array_walk_recursive($arr, function(&$v) use ($func) {
$v=$func($v);
});
return$arr;
}
?>A general solution for the problem of wanting to know the keys in the callback, and/or retain the key association in the returned array:
<?php
/**
* Like array_map() but callback also gets passed the current key as the
* first argument like so:
* function($key, $val, ...$vals) { ... }
* ...and returned array always maintains key association, even if multiple
* array arguments are passed.
*/
functionarray_map_assoc(callable$callback, array$array, array ...$arrays) {
$keys=array_keys($array);
array_unshift($arrays,$keys,$array);
returnarray_combine($keys,array_map($callback, ...$arrays));
}
?>
Because it uses array_map() directly, it behaves the same way in regard to ignoring the keys of subsequent array arguments. It also has the same variadic signature.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./**
* Function which recursively applies a callback to all values and also its
* keys, and returns the resulting array copy with the updated keys and
* values.
* PHP's built-in function array_walk_recursive() only applies the passed
* callback to the array values, not the keys, so this function simply applies
* the callback to the keys too (hence the need of working with a copy,
* as also updating the keys would lead to reference loss of the original
* array). I needed something like this, hence my idea of sharing it here.
*
* @param callable $func callback which takes one parameter (value
* or key to be updated) and returns its
* updated value
*
* @param array $arr array of which keys and values shall be
* get updated
*/
function array_map_recursive(
callable $func,
array $arr
) {
// Initiate copied array which will hold all updated keys + values
$result = [];
// Iterate through the key-value pairs of the array
foreach ( $arr as $key => $value ) {
// Apply the callback to the key to create the updated key value
$updated_key = $func( $key );
// If the iterated value is not an array, that means we have reached the
// deepest array level for the iterated key, so in that case, assign
// the updated value to the updated key value in the final output array
if ( ! is_array( $value ) ) {
$result[$updated_key] = $func( $value );
} else {
// If the iterated value is an array, call the function recursively,
// By taking the currently iterated value as the $arr argument
$result[$updated_key] = array_map_recursive(
$func,
$arr[$key]
);
}
} // end of iteration through k-v pairs
// And at the very end, return the generated result set
return $result;
} // end of array_map_recursive() function definition