PHP Transform a Collection

A transformation takes a collection, such as an array, and builds a new collection from it. The original is not changed.

PHP arrays come with a large family of ready-made functions for this: array_map applies a function to every element, array_merge joins arrays, array_combine glues keys to values, array_column picks one position out of every row, and implode turns an array into text. Where no ready-made function fits, a short foreach loop does the job.

The same PHP array works as a list and as a key:value store. A plain list has the keys 0, 1, 2 and so on; an associative array has keys you choose. Both keep their entries in insertion order, and both are used on this page.

The map operation applies the same function to every element and collects the answers in a new array of the same length. For example, it can turn 1, 2, 3 into 3, 6, 9.

In PHP this is exactly what array_map does: it takes the function first and the array second, and returns a new array. The function is often a short arrow function like fn($x) => $x * 3.

array_map never changes the original array. It builds and returns a new one, so you can keep both.

array_map calls the arrow function on every element and returns a new array. Here it multiplies each number by 3, and implode prints the new array as 3, 6, 9.

Sometimes the position of an element matters too. foreach gives you both the key and the value, and in a plain list the keys are the positions 0, 1, 2. Here each value is multiplied by its own index, so the program prints 0, 2, 6.

Sometimes some results should be dropped. Return null for them, then remove the null values with array_filter. Watch out: array_filter keeps the original keys, so the filtered array still has the keys 0 and 2 and json_encode prints it as {"0":3,"2":9}. array_values reindexes it into a clean list: [3,9].

To change the keys of an associative array, transform the keys and glue them back to the values. array_keys gives all keys, array_map('strtoupper', ...) makes them uppercase, and array_combine pairs the new keys with the old values.

To change the values, keep the keys and compute new values. array_map can walk two arrays at once — here the keys and the values — so each new value is the old value plus the length of its key: 1 + strlen("key1") is 5.

Zipping takes two arrays and pairs up their elements by position: the first with the first, the second with the second, and so on.

PHP has a classic idiom for this: array_map(null, $a, $b). When the callback is null and there are several arrays, array_map builds an array of pairs. Note that it does not stop at the shorter array — the missing places are filled with null — so zip arrays of the same length, or cut the longer one with array_slice first.

With null as the callback, array_map pairs the two arrays into an array of two-element arrays. json_encode shows the whole result in one line.

You do not always need the pairs themselves. Give array_map a real callback and both arrays, and it calls the function with one element from each. ucfirst makes the first letter of the animal name uppercase.

Unzipping is the reverse: one array of pairs becomes two arrays. array_column collects the element at one position from every pair — position 0 gives the words and position 1 gives the numbers.

Associating builds an associative array from a list. Each element gives you one key and one value. An array cannot hold the same key twice, so if two elements produce the same key, the later one wins.

The pattern is a plain foreach loop: start with an empty array and assign $result[$key] = $value for each element. PHP keeps the entries in the order they were added.

The element itself becomes the key, and a value is computed from it. Here the words are keys and their lengths are values, so the program prints {"one":3,"two":3,"three":5}.

The element becomes the value, and the key is computed from it. Here the key is the uppercase first letter, taken with $word[0] and strtoupper. Both two and three start with T, so three replaces two and the array has only two entries.

You can compute both the key and the value from the element. Here the key is the first letter and the value is the word length. Again the later T entry wins.

Sometimes one element carries both parts. explode splits a full name on the space into an array of words, and the list assignment [$first, $last] = ... unpacks it. The last name becomes the key and the first name becomes the value.

Flattening turns a nested collection, such as an array of arrays, into one plain array with all the elements in order.

In PHP, array_merge joins any number of arrays, and the three dots spread the inner arrays into the call: array_merge(...$nested).

The three dots turn array_merge(...$numberSets) into array_merge([1, 2, 3], [4, 5, 6]). Two inner arrays of three numbers become one array of six.

A flat map first takes an array out of every element, then joins all those arrays together. array_map reads the $values property of each container, and array_merge with the three dots glues the three arrays into one.

Often you want to show a collection as readable text, for example with commas between the elements.

In PHP, implode takes a separator and an array and returns one string. Numbers are turned into text automatically. The extras — a prefix, a postfix, a limit, or a transformation — are done with string concatenation, array_slice or array_map before joining.

implode puts ", " between the words and returns one string.

A prefix and a postfix are just text around the joined result. In PHP you add them with the . operator.

For a long array you may want to show only the first few elements. range(1, 100) builds the numbers, array_slice($numbers, 0, 10) takes the first 10, and "...>" is added at the end to show that more elements were cut off. implode turns the numbers into text by itself.

To change every element before joining, transform the array with array_map first, then implode the result. Here each word becomes "Element: " plus the word in uppercase.