PHP, a versatile scripting language, offers an array of functions to manipulate arrays efficiently. One such powerful function is array_map. This function transforms the elements of an array using a provided callback.

In this article, we’ll explore the ins and outs of PHP array_map and showcase its prowess through six illustrative code examples.

Let’s move on to learning how to write the syntax of PHP’s array_map.

Understanding the PHP array_map Function

array_map operates on each element of an array, applying a callback function to transform or manipulate the data in PHP. The function takes at least two parameters: the function and the array to be processed.

Additional arrays can be included as parameters if the callback requires multiple arrays.

array_map(callback, array1, ...) // Additional arrays can be included
  • callback: The function to be executed on each element.
  • array1: The array to be processed.

The number of arrays you can pass to array_map is not explicitly limited in the function definition. You can pass an unlimited number of arrays as needed to the arguments. The function, however, must be able to handle the same number of arguments as the number of arrays you provide.


function callback($param1, $param2, $param3, $param4, $param5) {
  // ...Your code here

array_map('callback', $array1, $array2, $array3, $array4, $array5 );

Let’s move forward to see examples.

Crafting a Custom Transformation Using PHP array_map Function

For a rudimentary introduction, let’s commence with the task of doubling the values within an array:


$array = [1, 2, 3, 4, 5];

$doubleArray = array_map(function($value) {
    return $value * 2;
}, $array);
// Result: $doubleArray = [2, 4, 6, 8, 10]

In this scenario, the function transforms each array element by doubling its value, resulting in a refined array with doubled elements.

Crafting a Custom Transformation Using array_map

Moving beyond arithmetic transformations, array_map gracefully accommodates custom functions. Consider the scenario where we aim to square each element:


function square($value) {
    return $value ** 2;

$array = [2, 4, 6, 8, 10];

$squaredArray = array_map('square', $array);

// Result: $squaredArray = [4, 16, 36, 64, 100]

Here, a dedicated square function encapsulates the squaring logic, seamlessly integrated into the array_map paradigm.

Synchronizing Multiple Arrays

The versatility of array_map truly shines when multiple arrays are involved. Consider the task of adding corresponding elements of two arrays:


$array1 = [1, 2, 3];
$array2 = [4, 5, 6];

$sumArray = array_map(function($a, $b) {
    return $a + $b;
}, $array1, $array2);

// Result: $sumArray = [5, 7, 9]

The function adeptly juggles parameters from both arrays, producing a harmonious array summing their respective elements.

Elegant String Manipulation

array_map extends its prowess beyond numeric operations, seamlessly accommodating string manipulations. In this instance, let’s trim excess spaces from each string within an array:


$array = ['  apple  ', 'banana  ', '  cherry'];

$trimmedArray = array_map('trim', $array);

// Result: $trimmedArray = ['apple', 'banana', 'cherry']

The trim function, a standard string manipulation tool, elegantly eradicates leading and trailing whitespaces.

Notably, array_map harmoniously interfaces with associative arrays. Suppose we wish to convert the values of a specific key to uppercase:


$students = [
    ['name' => 'John', 'grade' => 'a'],
    ['name' => 'Jane', 'grade' => 'b'],
    ['name' => 'Doe', 'grade' => 'c']

$uppercasedGrades = array_map(function($student) {
    $student['grade'] = strtoupper($student['grade']);
    return $student;
}, $students);

// Result: $uppercasedGrades is now an array with uppercase grades

Here, the callback selectively modifies the ‘grade’ key for each student, exemplifying array_map‘s adaptability.

A noteworthy facet of array_map is its graceful handling of arrays with varying lengths. Consider the following scenario:


$array1 = [1, 2, 3];
$array2 = [4, 5];

$resultArray = array_map(function($a, $b) {
    return $a + $b;
}, $array1, $array2);

// Result: $resultArray = [5, 7, 3]

In this case, array_map processes until the shortest array is exhausted, producing a result array based on available pairs. Then it completes the remaining elements of the other array.

Using the PHP array_map Function with a Class

Using array_map with a class involves applying a method of a class as the callback function. This can be particularly useful when you want to encapsulate the transformation logic within a class for better organization and reusability.

Let’s go through an example to illustrate how to use array_map with a class:


class Transformer {
    public function doubleValue($value) {
        return $value * 2;

// Example array
$array = [1, 2, 3, 4, 5];

// Create an instance of the Transformer class
$transformer = new Transformer();

// Use array_map with the class method
$transformedArray = array_map([$transformer, 'doubleValue'], $array);

// Result: $transformedArray = [2, 4, 6, 8, 10]

In this example:

  1. We define a class called Transformer with a method doubleValue that doubles the given value.
  2. We create an instance of the Transformer class.
  3. We use array_map with the callback being an array containing the instance of the class ($transformer) and the method name ('doubleValue'). This specifies that the doubleValue method of the Transformer class should be used as the callback function.
  4. array_map applies the doubleValue method to each element of the array, resulting in a new array where each value is doubled.

Wrapping Up

The PHP array_map function stands as a stalwart ally in array manipulation, offering a versatile means to streamline and enhance code expressiveness. This function empowers developers to navigate arrays with finesse, transforming data efficiently and concisely.

As you delve into the diverse applications showcased in the examples, the potential of array_map to elevate your PHP coding endeavors becomes increasingly evident.

Thank you for reading. For more details, visit the PHP Manual.