Working With PHP Arrays in the Right Way

In this tutorial, I am going to make a list of common PHP array functions with examples of usage and best practices. Every PHP developer must know how to use them and how to combine array functions to make code readable and short.

Also, there is a presentation with given code examples, so you can download it from the related links and show it to your colleagues to build a stronger team.

The Basics

Let's start with the basic functions that work with array keys and values. One of them is array_combine(), which creates an array using one array for keys and another for its values:

01 02 03 04 05 06 07 08 09 10 11 12

$keys = ['sky', 'grass', 'orange']; $values = ['blue', 'green', 'orange']; $array = array_combine($keys, $values); print_r($array); // Array // ( //     [sky] => blue //     [grass] => green //     [orange] => orange // )

You should know, that the function array_values() returns an indexed array of values, array_keys() returns an array of keys of a given array, and array_flip() exchanges keys with values:

01 02 03 04 05 06 07 08 09 10

print_r(array_keys($array)); // ['sky', 'grass', 'orange'] print_r(array_values($array)); // ['blue', 'green', 'orange'] print_r(array_flip($array)); // Array // ( //     [blue] => sky //     [green] => grass //     [orange] => orange // )

Make Your Code Shorter

The function list(), which is not really a function, but a language construction, is designed to assign variables in a short way. For example, here is a basic example of using the list() function:

01 02 03 04 05 06 07 08 09 10

// define array $array = ['a', 'b', 'c']; // without list() $a = $array[0]; $b = $array[1]; $c = $array[2]; // with list() list($a, $b, $c) = $array;

This construction works perfectly with functions like preg_slit() or  explode() . Also, you can skip some parameters, if you don't need them to be defined:

1 2 3

$string = 'hello|wild|world'; list($hello, , $world) = explode('|', $string); echo("$hello, $world"); // hello, world

Also, list() can be used with foreach, which makes this construction even better:

1 2 3 4 5 6

$arrays = [[1, 2], [3, 4], [5, 6]]; foreach ($arrays as list($a, $b)) {     $c = $a + $b;     echo($c . ', '); // 3, 7, 11, }

With the extract() function, you can export an associative array to variables. For every element of an array, a variable will be created with the name of a key and value as a value of the element:

1 2 3 4 5 6 7 8 9

$array = [     'clothes' => 't-shirt',     'size'    => 'medium',     'color'   => 'blue', ]; extract($array); echo("$clothes $size $color"); // t-shirt medium blue

Be aware that extract() is not safe if you are working with user data (like results of requests), so it is better to use this function with the flags EXTR_IF_EXISTS and EXTR_PREFIX_ALL.

The opposite of the previous function is the compact() function, which makes an associative array from variables:

01 02 03 04 05 06 07 08 09 10 11 12 13

$clothes = 't-shirt'; $size = 'medium'; $color = 'blue'; $array = compact('clothes', 'size', 'color'); print_r($array); // Array // ( //     [clothes] => t-shirt //     [size] => medium //     [color] => blue // )

Filtering Functions

There is a great function for array filtering, and it is called array_filter(). Pass the array as the first param and an anonymous function as the second param. Return true in a callback function if you want to leave this element in the array, and false if you don't:

1 2 3 4 5 6 7

$numbers = [20, -3, 50, -99, 55]; $positive = array_filter($numbers, function($number) {     return $number > 0; }); print_r($positive); // [0 => 20, 2 => 50, 4 => 55]

There is a way to filter not only by the values. You can use ARRAY_FILTER_USE_KEY or ARRAY_FILTER_USE_BOTH as a third parameter to pass the key or both value and key to the callback function.

Also, you can call array_filter() without a callback to remove all empty values:

1 2 3 4 5

$numbers = [-1, 0, 1]; $not_empty = array_filter($numbers); print_r($not_empty); // [0 => -1, 2 => 1]

You can get only unique values from an array using the array_unique() function. Notice that the function will preserve the keys of the first unique elements:

01 02 03 04 05 06 07 08 09 10 11 12 13

$array = [1, 1, 1, 1, 2, 2, 2, 3, 4, 5, 5]; $uniques = array_unique($array); print_r($uniques); // Array // ( //     [0] => 1 //     [4] => 2 //     [7] => 3 //     [8] => 4 //     [9] => 5 // )

With array_column(), you can get a list of column values from a multi-dimensional array, like an answer from a SQL database or an import from a CSV file. Just pass an array and column name:

1 2 3 4 5 6 7 8 9

$array = [     ['id' => 1, 'title' => 'tree'],     ['id' => 2, 'title' => 'sun'],     ['id' => 3, 'title' => 'cloud'], ]; $ids = array_column($array, 'id'); print_r($ids); // [1, 2, 3]

Starting from PHP 7, array_column() becomes even more powerful, because it is now allowed to work with an array of objects. So working with an array of models just became easier:

1 2	$cinemas = Cinema::find()->all(); $cinema_ids = array_column($cinemas, 'id'); // php7 forever!

Walking Through the Arrays

Using array_map(), you can apply a callback to every element of an array. You can pass a function name or anonymous function to get a new array based on the given array:

01 02 03 04 05 06 07 08 09 10 11

$cities = ['Berlin', 'KYIV', 'Amsterdam', 'Riga']; $aliases = array_map('strtolower', $cities); print_r($aliases); // ['berlin', 'kyiv, 'amsterdam', 'riga'] $numbers = [1, -2, 3, -4, 5]; $squares = array_map(function($number) {     return $number ** 2; }, $numbers); print_r($squares);  // [1, 4, 9, 16, 25]

There is a myth that there is no way to pass values and keys of an array to a callback, but we can bust it:

01 02 03 04 05 06 07 08 09 10 11 12 13 14

$model = ['id' => 7, 'name'=>'James']; $callback = function($key, $value) {     return "$key is $value"; }; $res = array_map($callback, array_keys($model), $model); print_r($res); // Array // ( //     [0] => id is 7 //     [1] => name is James // )

But this looks dirty. It is better to use array_walk() instead. This function looks the same as array_map(), but it works differently. First of all, an array is passed by a reference, so array_walk() doesn't create a new array, but changes a given array. So as a source array, you can pass the array value by a reference in a callback. Array keys can also be passed easily:

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18

$fruits = [     'banana' => 'yellow',     'apple' => 'green',     'orange' => 'orange', ]; array_walk($fruits, function(&$value, $key) {     $value = "$key is $value"; }); print_r($fruits); // Array // ( //     [banana] => banana is yellow //     [apple] => apple is green //     [orange] => orange is orange // )

Joining the Arrays

The best way to merge two or more arrays in PHP is to use the array_merge() function. Items of arrays will be merged together, and values with the same string keys will be overwritten with the last value:

01 02 03 04 05 06 07 08 09 10 11 12

$array1 = ['a' => 'a', 'b' => 'b', 'c' => 'c']; $array2 = ['a' => 'A', 'b' => 'B', 'D' => 'D']; $merge = array_merge($array1, $array2); print_r($merge); // Array // ( //     [a] => A //     [b] => B //     [c] => c //     [D] => D // )

To remove array values from another array (or arrays), use array_diff(). To get values which are present in given arrays, use array_intersect(). The next examples will show how it works:

1 2 3 4 5 6 7 8

$array1 = [1, 2, 3, 4]; $array2 =       [3, 4, 5, 6]; $diff = array_diff($array1, $array2); print_r($diff); // [0 => 1, 1 => 2] $intersect = array_intersect($array1, $array2); print_r($intersect);  // [2 => 3, 3 => 4]

Do the Math With Array Values

Use array_sum() to get a sum of array values, array_product() to multiply them, or create your own formula with array_reduce():

1 2 3 4 5 6 7 8

$numbers = [1, 2, 3, 4, 5]; echo(array_sum($numbers)); // 15 echo(array_product($numbers)); // 120 echo(array_reduce($numbers, function($carry, $item) {     return $carry ? $carry / $item : 1; })); // 0.0083 = 1/2/3/4/5

To count all the values of an array, use array_count_values(). It will give all unique values of a given array as keys and a count of these values as a value:

01 02 03 04 05 06 07 08 09 10 11

$things = ['apple', 'apple', 'banana', 'tree', 'tree', 'tree']; $values = array_count_values($things); print_r($values); // Array // ( //     [apple] => 2 //     [banana] => 1 //     [tree] => 3 // )

Generating Arrays

To generate an array with a given size and the same value, use array_fill():

1 2	$bind = array_fill(0, 5, '?'); print_r($bind); // ['?', '?', '?', '?', '?']

To generate an array with a range in of keys and values, like day hours or letters, use range():

1 2 3 4 5

$letters = range('a', 'z'); print_r($letters); // ['a', 'b', ..., 'z'] $hours = range(0, 23); print_r($hours); // [0, 1, 2, ..., 23]

To get a part of an array—for example, just the first three elements—use array_slice():

1 2 3

$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; $top = array_slice($numbers, 0, 3); print_r($top); // [1, 2, 3]

Sorting Arrays

It is good to remember that every sorting function in PHP works with arrays by a reference and returns trueon success or false on failure. There's a basic sorting function called sort(), and it sorts values in ascending order without preserving keys. The sorting function can be prepended by the following letters:

• a, sort preserving keys
• k, sort by keys
• r, sort in reverse/descending order
• u, sort with a user function

You can see the combinations of these letters in the following table:

Array Functions

Array Functions

• array_change_key_case — Changes the case of all keys in an array
• array_chunk — Split an array into chunks
• array_column — Return the values from a single column in the input array
• array_combine — Creates an array by using one array for keys and another for its values
• array_count_values — Counts all the values of an array
• array_diff_assoc — Computes the difference of arrays with additional index check
• array_diff_key — Computes the difference of arrays using keys for comparison
• array_diff_uassoc — Computes the difference of arrays with additional index check which is performed by a user supplied callback function
• array_diff_ukey — Computes the difference of arrays using a callback function on the keys for comparison
• array_diff — Computes the difference of arrays
• array_fill_keys — Fill an array with values, specifying keys
• array_fill — Fill an array with values
• array_filter — Filters elements of an array using a callback function
• array_flip — Exchanges all keys with their associated values in an array
• array_intersect_assoc — Computes the intersection of arrays with additional index check
• array_intersect_key — Computes the intersection of arrays using keys for comparison
• array_intersect_uassoc — Computes the intersection of arrays with additional index check, compares indexes by a callback function
• array_intersect_ukey — Computes the intersection of arrays using a callback function on the keys for comparison
• array_intersect — Computes the intersection of arrays
• array_key_exists — Checks if the given key or index exists in the array
• array_keys — Return all the keys or a subset of the keys of an array
• array_map — Applies the callback to the elements of the given arrays
• array_merge_recursive — Merge two or more arrays recursively
• array_merge — Merge one or more arrays
• array_multisort — Sort multiple or multi-dimensional arrays
• array_pad — Pad array to the specified length with a value
• array_pop — Pop the element off the end of array
• array_product — Calculate the product of values in an array
• array_push — Push one or more elements onto the end of array
• array_rand — Pick one or more random keys out of an array
• array_reduce — Iteratively reduce the array to a single value using a callback function
• array_replace_recursive — Replaces elements from passed arrays into the first array recursively
• array_replace — Replaces elements from passed arrays into the first array
• array_reverse — Return an array with elements in reverse order
• array_search — Searches the array for a given value and returns the first corresponding key if successful
• array_shift — Shift an element off the beginning of array
• array_slice — Extract a slice of the array
• array_splice — Remove a portion of the array and replace it with something else
• array_sum — Calculate the sum of values in an array
• array_udiff_assoc — Computes the difference of arrays with additional index check, compares data by a callback function
• array_udiff_uassoc — Computes the difference of arrays with additional index check, compares data and indexes by a callback function
• array_udiff — Computes the difference of arrays by using a callback function for data comparison
• array_uintersect_assoc — Computes the intersection of arrays with additional index check, compares data by a callback function
• array_uintersect_uassoc — Computes the intersection of arrays with additional index check, compares data and indexes by separate callback functions
• array_uintersect — Computes the intersection of arrays, compares data by a callback function
• array_unique — Removes duplicate values from an array
• array_unshift — Prepend one or more elements to the beginning of an array
• array_values — Return all the values of an array
• array_walk_recursive — Apply a user function recursively to every member of an array
• array_walk — Apply a user supplied function to every member of an array
• array — Create an array
• arsort — Sort an array in reverse order and maintain index association
• asort — Sort an array and maintain index association
• compact — Create array containing variables and their values
• count — Count all elements in an array, or something in an object
• current — Return the current element in an array
• each — Return the current key and value pair from an array and advance the array cursor
• end — Set the internal pointer of an array to its last element
• extract — Import variables into the current symbol table from an array
• in_array — Checks if a value exists in an array
• key_exists — Alias of array_key_exists
• key — Fetch a key from an array
• krsort — Sort an array by key in reverse order
• ksort — Sort an array by key
• list — Assign variables as if they were an array
• natcasesort — Sort an array using a case insensitive "natural order" algorithm
• natsort — Sort an array using a "natural order" algorithm
• next — Advance the internal pointer of an array
• pos — Alias of current
• prev — Rewind the internal array pointer
• range — Create an array containing a range of elements
• reset — Set the internal pointer of an array to its first element
• rsort — Sort an array in reverse order
• shuffle — Shuffle an array
• sizeof — Alias of count
• sort — Sort an array
• uasort — Sort an array with a user-defined comparison function and maintain index association
• uksort — Sort an array by keys using a user-defined comparison function
• usort — Sort an array by values using a user-defined comparison function