Array Functions

Question 1

Adding arrays (+)

Answer 1

Arrays will be added together and values with the same keys will be overwritten by subsequently added arrays.

Question 2

array_change_key_case( array $array [, $case = CASE_LOWER] )

Answer 2

Returns an array with all keys from $array lowercased or uppercased. Numbered indices are left as is.

Question 3

array_chunk( array $array, int $size [, bool $preserve_keys = false] )

Answer 3

Chunks an array into arrays with $size elements. That last chunk may contain less than $size elements.

Question 4

array_column( array $input, mixed $column_key [, mixed $index_key = null ] )

Answer 4

$input should be a multi-dimensional array.

Returns the values from a single column of the $input, identified by the $column_key.

Optionally, an $index_key may be provided to index the values in the returned array by the values from the $index_key column of the input array.

Question 5

array_combine( array $keys, array $values )

Answer 5

Creates an array by using the values from the $keys array as keys and the values from the $values array as the corresponding values.

Question 6

array_count_values( array $array )

Answer 6

Returns the number of times each value in $array appears by returning an array in the form “$arrayValue” => “count”

Question 7

array_diff( array $array1, array $array2 [, array $… ] )

Answer 7

Compares $array1 against one or more other arrays and returns the values in $array1 that are not present in any of the other arrays.

Question 8

array_diff_assoc( array $array1, array $array2 [, array $…] )

Answer 8

Compares $array1 against $array2 and returns the difference.

Unlike array_diff() the array keys are also used in the comparison.

Question 9

array_diff_key( array $array1, array $array2 [, array $…] )

Answer 9

Compares the keys from $array1 against the keys from $array2 and returns the difference.

This function is like array_diff() except the comparison is done on the keys instead of the values.

Question 10

array_diff_uassoc( array $array2, array $array2 [, array $…], callable $key_compare_func )

Answer 10

Compares $array1 against $array2 and returns the difference. Unlike array_diff() the array keys are used in the comparison.

Unlike array_diff_assoc() a user supplied callback is used for the indices comparison, not internal function.

Question 11

array_diff_ukey( array $array1, array $array2 [, array $…], callable $key_compare_func )

Answer 11

Compares the keys from $array1 against the keys from $array2 and returns the difference. This function is like array_diff() except the comparison is done on the keys instead of the values.

Unlike array_diff_key() a user supplied callback function is used for the indices comparison, not internal function.

Question 12

array_fill( int $start_index, int $num, mixed $value )

Answer 12

Fills as array with $num entries of the value of the $value parameter, keys starting at the $start_index parameter.

Question 13

array_fill_keys( array $keys, mixed $value )

Answer 13

Fills an array with the values of the $value parameter, using the values of the $keys array as keys.

Question 14

array_filter( array $array [, callable $callback [, int flag = 0] ] )

Answer 14

Iterates over each value in the $array passing them to the $callback function.

If the $callback function returns true, the current value from $array is returned into the result array. Array keys are preserved.

Question 15

array_flip( array $array )

Answer 15

Returns an array in flip order, i.e. keys from $array become values and values from $array become keys.

Note that the values of $array need to be valid keys, i.e. they need to be either integer or string. A warning will be emitted if a value has the wrong type, and the key/value pair in question will not be included in the result.

If a value has several occurrences, the latest key will be used as its value, and all others will be lost.

Question 16

array_intersect( array $array1, array $array2 [, array $…] )

Answer 16

Returns an array containing all the values of $array1 that are present in all the arguments.

Keys are preserved.

Question 17

array_intersect_assoc( array $array1, array $array2 [, array $…] )

Answer 17

Returns an array containing all the values of $array1 that are present in all the arguments.

The keys are also used in the comparison unlike in array_intersect()

Question 18

array_intersect_key( array $array1, array $array2 [, array $…] )

Answer 18

Returns as array containing all the entries of $array1 which have keys that are present in all the arguments.

Question 19

array_intersect_uassoc( array $array1, array $array2, [, array $…], callable $key_compare_func )

Answer 19

Returns an array containing all the values of $array1 that are present in all the arguments.

The keys are used in the comparison unlike in array_intersect()

Question 20

array_intersect_ukey( array $array1, array $array2 [, array $…], callable $key_compare_func )

Answer 20

Returns an array containing all the values of $array1 which have matching keys that are present in all the arguments.

Question 21

array_keys( array $input [, mixed $search_value] )

Answer 21

Returns an array of values containing the keys from $input.

If $search_value is specified, only keys corresponding to $input values of $search_value will be returned.

Question 22

array_key_exists( mixed $key, array $source )

Answer 22

Returns a boolean based on the results of searching $source for a key of $key.

Question 23

array_map( callable $callback, array $array1 [, array $…] )

Answer 23

Returns an array containing all the elements of $array1 after applying the $callback function to each one.

The number of parameters that the $callback function accepts should match the number of arrays passed to array_map()

Question 24

array_merge( array $array1, array $array2 [, array…] )

Answer 24

Returns an array with all of the array arguments merged, or appended, onto $array1.

Question 25

array_merge_recursive( array $array1 [, array $…] )

Answer 25

Merges the elements of one or more arrays together so that the values of one are appended to the end of the previous one. It returns the resulting array.

If the input arrays have the same string keys, then the values for these keys are merged together into an array, and this is done recursively, so that if one of the values is an array itself, the function will merge it with a corresponding entry in another array too. If, however, the arrays have the same numeric key, the later value will not overwrite the original value, but will be appended.

Question 26

array_multisort( array &$array1 [, mixed $array1_sort_order = SORT_ASC [, mixed $array1_sort_flags = SORT_REGULAR [, mixed $…] ] ] )

Answer 26

Can be used to sort several arrays at once, or a multi-dimensional array by one or more dimensions.

Associative (string) keys will be maintained, but numeric keys will be re-indexed.

Question 27

array_pad( array $array, int $size, mixed $value )

Answer 27

Returns a copy of the $array padded to size specified by $size with value $value. If $size is positive then the array is padded on the right, if it’s negative then on the left. If the absolute value of $size is less than or equal to the length of the $array then no padding takes place.

It is possible to add at most 1048576 elements at a time.

Question 28

array_pop( array &$array )

Answer 28

Pops and returns the last value of the $array, shortening the $array by one element.

This function will reset() the array pointer of the input array after use.

Question 29

array_product( array $array )

Answer 29

Returns the product of values in an array.

Question 30

array_push( array &$array, mixed $value1 [, mixed $…] )

Answer 30

Treats $array as a stack and pushes the passed variables onto the end of $array. The length of $array increases by the number of variables pushed.

Sames as $array[] = $var;

Question 31

array_rand( array $array [, int num = 1] )

Answer 31

Picks one or more random entries out of an array and returns the key (or keys) of the random entries.

It uses a pseudo random number generator that is not suitable for cryptographic purposes.

Question 32

array_reduce( array $array, callable $callback [, mixed $initial = NULL ] )

Answer 32

Applies iteratively the callback function to the elements of the $array so as to reduce the array to a single value.

$callback looks like this:
callback(mixed $carry, mixed $item)

$carry holds the value of the previous iteration whereas $item holds the value of the current iteration.

Question 33

array_replace( array $array1, array $array2 [, array $…] )

Answer 33

Replaces the values of $array1 with values having the same keys in each of the following arrays.

If a key from the first array exists in the second array, its value will be replaced by the value from the second array.

If the key exists in the second array, and not in the first, it will be created in the first array.

If a key only exists in the first array, it will be left as is.

If several arrays are passed for replacement, they will be processed in order, the later arrays overwriting the previous values.

Question 34

array_replace_recursive( array $array1, array $array2 [, array $… ] )

Answer 34

Replaces the values of $array1 with the same values from all of the following arrays.

If a key from the first array exists in the second array, its value will be replaced by the value from the second array.

If the key exists in the second array, and not the first, it will be created in the first array.

If a key only exists in the first array, it will be left as is.

If several arrays are passed for replacement, they will be processed in order, the later array overwriting the previous values.

Question 35

array_reverse( array $source [, boolean $preserve_keys] )

Answer 35

Returns an array with the order of $source values reversed, including the keys.

Passing TRUE for $preserve_keys will cause the keys to not be reversed.

Question 36

array_search( mixed $needle, array $haystack [, boolean $strict] )

Answer 36

Returns the key of the element that contains $needle if it is found in $haystack. Returns FALSE if not found.

If $strict is set to TRUE, type matching occurs.

Be sure to use the strict === operator because if the index of the found value is 0, it may be incorrectly coerced to mean FALSE.

Question 37

array_shift( array &$array )

Answer 37

Shift the first value of the $array off and returns it, shortening the $array by one element and moving everything down.

All numerical array keys will be modified to start counting from zero while literal keys won’t be touched.

This function will reset() the array pointer of the input array after use.

Question 38

array_slice( array $array, int $offset [, int $length = NULL [, bool $preserve_keys = false] ] )

Answer 38

Returns the sequence of elements from the array $array as specified by the $offset and $length parameters.

Question 39

array_splice( array &$input, int $offset [, int $length = count($input) [, mixed $replacement = array() ] ] )

Answer 39

Removes the elements designated by $offset and $length from the $input array, and replaces them with the elements of the $replacement array, if supplied.

Numeric keys in $input are not preserved.

If $replacement is not an array, it will be typecast to one.

Question 40

array_sum( array $array )

Answer 40

Returns the sum of values in an array.

Question 41

array_udiff_assoc( array $array1, array $array2 [, $…], callable $value_compare_func )

Answer 41

Computes the difference of arrays with additional index check, compares data by a callback function.

Question 42

array_values( array $input )

Answer 42

Returns a numerically-indexed array containing all of the values from $input.

Question 43

arsort( array $subject [, int $sort_flag] )

Answer 43

Same as asort(), but in DESC order.

Question 44

asort( array $subject [, int $sort_flag] )

Answer 44

Works on associative arrays too - keeps indices matched up to sorted values. Can be handy for numerically-indexed arrays as well.

Question 45

count( array $array )

Answer 45

Returns the number of values in the array passed in

Question 46

explode( string $separator, string $subject [, int $limit])

Answer 46

Returns an array of pieces of $subject that were split on $separator.

$limit indicates how many splits to perform before just returning the remain portion of $subject.

Question 47

implode( string $glue, array $pieces )

Answer 47

Returns a string that is the values of the $pieces array glued together by $glue

Question 48

in_array( mixed $needle, array $haystack [, boolean $strict] )

Answer 48

Returns a boolean if the value $needle is found in $haystack.

If optional $strict is passed as TRUE, type matching also occurs.

Question 49

is_array( array $array )

Answer 49

Returns a Boolean as to whether the value passed in is an array or not

Question 50

join( string $glue, array $pieces )

Answer 50

Returns a string that is the the values of the $pieces array glued together by $glue

Question 51

krsort( array $subject [, int $sort_flag] )

Answer 51

Reverse of ksort().

Question 52

ksort( array $subject [, int $sort_flag] )

Answer 52

Sorts array keys in ASC order.

Question 53

max( array $numbers )

Answer 53

Returns the largest number from $numbers

Question 54

min( array $numbers )

Answer 54

Returns the smallest number from $numbers

Question 55

range( mixed $low, mixed $high [, int $step])

Answer 55

Returns an array with values starting at $low and ending at $high, with increments between $low and $high being $step apart

Question 56

rsort( array $subject [, int $sort_flag] )

Answer 56

Same as sort(), but in DESC order.

Question 57

sort( array $subject [, int $sort_flag] )

Answer 57

Returns an array containing ASC sorted values from $subject.

Refer to php.net for $sort_flag values.

Question 58

usort( array $subject [, string $compare_function] )

Answer 58

Returns a custom-sorted array in ASC order. $subject is sorted by the user-defined $compare_function, which should accepts two arguments, mixed $a and mixed $b.

$compare_function must return 1 if $a > $b, a -1 if $a < $b, and 0 if $a == $b.

$compare_function is referred to as a “callback function”.