PHP array_map() function usage and examples

There are many built-in functions in PHP, among which the array_map() function is one of the very useful functions. This function can accept one or more arrays as input and return a new array. Each element of the new array is the result of the input array being processed by the callback function. The array_map() function is mainly used to simplify operations, such as operating on each element in an array and returning a new array.

The syntax of the array_map() function is as follows:

array_map(callable $callback, array ...$arrays): array

Among them, $callback is the callback function, and $arrays is one or more arrays. The function iterates through all arrays in $arrays, calls the callback function on each array element in turn, and finally returns an array containing all new elements.

The callback function is a function that operates on the input elements. The number of parameters received by the callback function must be the same as the number of elements of the input array, and the first parameter is always an element of the input array. A callback function can have multiple input arrays, but each input array must have the same number of elements.

The following is a simple example using the array_map() function to double the elements in an array:

function double($n) {
  return $n * 2;
}

$numbers = array(1, 2, 3, 4, 5);
$doubled = array_map('double', $numbers);

print_r($doubled);

Output:

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

In this example, we first define A callback function double() that multiplies the input value by 2 and returns the result. Then we define an array $numbers, which contains integers from 1 to 5. Next, we call array_map() with the double() function as the callback function and the $numbers array as input. Finally, we store the output in the $doubled array and print it on the screen.

We can also use multiple input arrays in the callback function. For example, array_map() can be used to sum the elements in two arrays:

function sum($a, $b) {
  return $a + $b;
}

$numbers1 = array(1, 2, 3, 4, 5);
$numbers2 = array(10, 20, 30, 40, 50);
$summed = array_map('sum', $numbers1, $numbers2);

print_r($summed);

Output:

Array
(
    [0] => 11
    [1] => 22
    [2] => 33
    [3] => 44
    [4] => 55
)

In this example, we define a new callback function sum() , which takes two input arguments and adds them. We create two arrays $numbers1 and $numbers2 and pass them to the array_map() function with the sum() function as a callback. The function returns a new array $summed that contains the result of adding the elements in the $numbers1 and $numbers2 arrays.

array_map() also has a very widely used feature: using anonymous functions as callback functions. Anonymous functions are a new feature introduced in PHP 5.3 that allow us to dynamically create functions when necessary. The following is an example of using an anonymous function to calculate the length of all strings in a string array:

$strings = array('hello', 'world', 'goodbye');
$lengths = array_map(function($str) { return strlen($str); }, $strings);

print_r($lengths);

Output:

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

In this example, we define an anonymous function that Accepts a string as input and returns the length of that string. We pass this anonymous function as a callback function to the array_map() function, using the $strings array as input. Finally, a new array $lengths is output, which contains the lengths of all the strings in the $strings array.

In short, the array_map() function is a very useful tool that can make array operations clearer and more concise. Callback functions are also very customizable and can easily operate on various data types. Hope this article can help you better understand and use the array_map() function.

The above is the detailed content of PHP array_map() function usage and examples. For more information, please follow other related articles on the PHP Chinese website!