Array Mapping

Mapping arrays in PHP allows for the transformation of each element in an array, producing a new array with the transformed values. This is useful when you want to apply a specific operation or function to every element in an array.

Another way of thinking of it is that mapping an array in PHP is like giving a set of instructions to every item in a list. For example, imagine you have a list of numbers, and you want to increase each number by 2. Instead of manually changing each number one by one, you can "map" an instruction (in this case, "add 2") to every number in the list all at once.

Mapping can greatly simplify your code, making it more readable and maintainable, especially when dealing with large datasets. It also aligns well with functional programming principles, encouraging the use of pure functions that avoid side effects, enhancing predictability and testability.

Using Loops

Technically, we don't need to use any special functions for mapping an array. We can use any of the loop keywords, such as foreach. You can perform mapping in PHP using a foreach loop to iterate over each element in an array and apply a function to it.

Here's an example where we'll create a new array with each element doubled from the original array:

$numbers = array(1, 2, 3, 4, 5);
$doubledNumbers = array();
 
foreach ($numbers as $number) {
  $doubledNumbers[] = $number * 2;
}
 
// Now, $doubledNumbers is array(2, 4, 6, 8, 10)

In this example, $numbers is the original array, and $doubledNumbers is the new array that will hold the results of the mapping operation. We use a foreach loop to iterate over each number in $numbers, multiply it by 2, and add the result to $doubledNumbers.

Using array_map()

You can achieve the same result using the array_map() function. The syntax for this function is the following:

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

Parameters

$callback is the function to run for each element in the arrays. This can be any valid callable: a function name as a string, an anonymous function, or an array with an object reference and a method name. The callback function should return a value that will be included in the resulting array.
$array is the first array to process. array_map() will iterate over this array and pass each value to the callback function.
$arrays are optional additional arrays to process. If more than one array is provided, array_map() will pass corresponding elements from each array to the callback function. All arrays should have the same length; if they don't, array_map() will behave as though they do, using null for missing elements.

Basic Example

$numbers = array(1, 2, 3, 4, 5);
 
$doubledNumbers = array_map(function($number) {
    return $number * 2;
}, $numbers);
 
// Now, $doubledNumbers is array(2, 4, 6, 8, 10)

In this case, array_map() applies the anonymous function to every element in the $numbers array, resulting in the $doubledNumbers array.

There are a few reasons why you might want to use array_map() instead of a foreach loop:

array_map() aligns well with functional programming principles. You're applying a function (the first argument) to each element in an array (the second argument), which can lead to cleaner and more readable code.
With array_map(), you can achieve the same result in fewer lines of code compared to a foreach loop, which can make your code more concise.

However, keep in mind that array_map() can be slower than a foreach loop for large arrays, as it involves creating a new array and calling a function for each element. So there's a trade-off between code readability and performance that you need to consider.

Filtering items in an array

Filtering an array means selecting certain elements from the array based on specific criteria and creating a new array with those elements. The criteria are defined by a function that you provide, which is applied to each element in the array. If the function returns true for an element, that element is included in the new array. If the function returns false, the element is not included. This allows you to create a subset of the original array that meets your specific conditions.

The array_filter() function in PHP is used to filter elements of an array using a callback function. It iterates over each value in the array, passing them to the callback function. If the callback function returns true, the current value from the input array is returned to the resulting array.

array_filter(array $array, ?callable $callback = null, int $mode = 0): array

Parameters

$array - The input array to filter.
$callback - The callback function to use. This function takes an array value as its argument and should return true for values you want to keep and false for values you want to filter out. If no callback function is supplied, all entries of the array which equal false will be removed.
$mode - This is an optional parameter and can take the following values: ARRAY_FILTER_USE_KEY - pass key as the only argument to callback instead of the value and ARRAY_FILTER_USE_BOTH - pass both value and key as arguments to callback instead of the value.

Example

Let's look at an example where we filter out the even numbers from an array:

$numbers = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 
$result = array_filter($numbers, function($value) {
  return $value % 2 == 1; // Returns true for odd numbers
});
 
// The resulting array ($result) will be: array(1, 3, 5, 7, 9)

In this example, array_filter() iterates over each value in the $numbers array and passes it to the callback function. The function checks if the current value is odd ($value % 2 == 1), and if it is, it returns true, so that value is included in the $result array. If the function returns false (for even numbers), that value is not included in the $result array. The result is an array that only contains the odd numbers from the original array.

Reducing an Array

Reducing an array refers to the process of taking an array of values and reducing them to a single value. The reduction is performed by applying a function that you provide to each element in the array in a cumulative way.

The array_reduce() function in PHP is used for this purpose. It iterates over each value in the array, passing them to a callback function along with the return value from the previous iteration. The result of this callback function becomes the return value for the next iteration, and so on.

Here's the syntax for array_reduce():

array_reduce(array $array, callable $callback, mixed $initial = null): mixed

Parameters

$array - The input array to reduce.
$callback - The callback function to use. This function takes two arguments: the return value from the previous iteration (or the initial value for the first iteration) and the current array value. It should return a value that will be used as the return value for the next iteration.
$initial - The initial value to use for the first iteration. This is optional. If it's not provided, the first array element is used.

Example

Let's look at an example where we calculate the product of an array of numbers:

$numbers = array(1, 2, 3, 4, 5);
 
$product = array_reduce($numbers, function($carry, $item) {
  return $carry * $item;
}, 1);  // initial value is 1, as anything multiplied by 1 remains the same
 
// The resulting product will be: 120 (1*2*3*4*5)

In this example, array_reduce() iterates over each value in the $numbers array and passes it to the callback function along with the product of the previous numbers (stored in $carry). The function multiplies $carry by the current number ($item) and returns the result, which is then used as the $carry value for the next iteration. The result is the product of all the numbers in the array.

Key Takeaways

Mapping is a process that transforms every element in an array using a specific function or operation.
Mapping can be useful when you want to perform an operation on every element in an array and create a new array with the results.
The array_map() function in PHP can be used to apply a callback function to each element in one or more arrays.
Using array_map() can result in cleaner, more readable code by following functional programming principles.
array_map() returns a new array and doesn't modify the original array, which can avoid side effects and make your code easier to understand and debug.
The array_filter() function in PHP is used to filter elements of an array using a callback function. If the callback function returns true, the current value from the input array is returned to the resulting array.
The array_reduce() function in PHP is used to reduce an array of values down to a single value. It applies a callback function to each element in the array, passing in the return value from the previous iteration and the current value, and returns a single value as a result.