This is one stop global knowledge base where you can learn about all the products, solutions and support features.
(PHP 5 >= 5.5.0, PHP 7, PHP 8)
array_column — Return the values from a single column in the input array
array_column(array $array, int|string|null $column_key, int|string|null $index_key = null): array
array_column()
returns the values from a single column of the
array
, 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.
array
A multi-dimensional array or an array of objects from which to pull a column of values from. If an array of objects is provided, then public properties can be directly pulled. In order for protected or private properties to be pulled, the class must implement both the __get() and __isset() magic methods.
column_key
The column of values to return. This value may be an integer key of the column you wish to retrieve, or it may be a string key name for an associative array or property name. It may also be
null
to return complete arrays or objects (this is useful together with
index_key
to reindex the array).
index_key
The column to use as the index/keys for the returned array. This value may be the integer key of the column, or it may be the string key name. The value is cast as usual for array keys (however, prior to PHP 8.0.0, objects supporting conversion to string were also allowed).
Returns an array of values representing a single column from the input array.
| Version | Description |
|---|---|
| 8.0.0 |
Objects in columns indicated by
index_key
parameter will no longer be cast to string and will now throw a
TypeError
instead.
|
Example #1 Get the column of first names from a recordset
<?php
// Array representing a possible record set returned from a database
$records = array(
array(
'id' => 2135,
'first_name' => 'John',
'last_name' => 'Doe',
),
array(
'id' => 3245,
'first_name' => 'Sally',
'last_name' => 'Smith',
),
array(
'id' => 5342,
'first_name' => 'Jane',
'last_name' => 'Jones',
),
array(
'id' => 5623,
'first_name' => 'Peter',
'last_name' => 'Doe',
)
);
$first_names = array_column($records, 'first_name');
print_r($first_names);
?>
The above example will output:
Array
(
[0] => John
[1] => Sally
[2] => Jane
[3] => Peter
)
Example #2 Get the column of last names from a recordset, indexed by the "id" column
<?php
// Using the $records array from Example #1
$last_names = array_column($records, 'last_name', 'id');
print_r($last_names);
?>
The above example will output:
Array
(
[2135] => Doe
[3245] => Smith
[5342] => Jones
[5623] => Doe
)
Example #3 Get the column of usernames from the public "username" property of an object
<?php
class User
{
public $username;
public function __construct(string $username)
{
$this->username = $username;
}
}
$users = [
new User('user 1'),
new User('user 2'),
new User('user 3'),
];
print_r(array_column($users, 'username'));
?>
The above example will output:
Array
(
[0] => user 1
[1] => user 2
[2] => user 3
)
Example #4 Get the column of names from the private "name" property of an object using the magic __get() method.
<?php
class Person
{
private $name;
public function __construct(string $name)
{
$this->name = $name;
}
public function __get($prop)
{
return $this->$prop;
}
public function __isset($prop) : bool
{
return isset($this->$prop);
}
}
$people = [
new Person('Fred'),
new Person('Jane'),
new Person('John'),
];
print_r(array_column($people, 'name'));
?>
The above example will output:
Array
(
[0] => Fred
[1] => Jane
[2] => John
)
(PHP 5, PHP 7, PHP 8)
array_combine — Creates an array by using one array for keys and another for its values
array_combine(array $keys, array $values): array
Creates an
array
by using the values from the
keys
array as keys and the values from the
values
array as the corresponding values.
keys
Array of keys to be used. Illegal values for key will be converted to string .
values
Array of values to be used
Returns the combined array .
As of PHP 8.0.0, a
ValueError
is thrown if the number of elements in
keys
and
values
does not match. Prior to PHP 8.0.0, a
E_WARNING
was emitted instead.
| Version | Description |
|---|---|
| 8.0.0 |
array_combine()
will now throw a
ValueError
if the number of elements for each array is not equal; previously this function returned
false
instead.
|
Example #1 A simple array_combine() example
<?php
$a = array('green', 'red', 'yellow');
$b = array('avocado', 'apple', 'banana');
$c = array_combine($a, $b);
print_r($c);
?>
The above example will output:
Array
(
[green] => avocado
[red] => apple
[yellow] => banana
)
(PHP 4, PHP 5, PHP 7, PHP 8)
array_count_values — Counts all the values of an array
array_count_values(array $array): array
array_count_values()
returns an array using the values of
array
(which must be
int
s or
string
s) as keys and their frequency in
array
as values.
array
The array of values to count
Returns an associative array of values from
array
as keys and their count as value.
Throws
E_WARNING
for every element which is not
string
or
int
.
Example #1 array_count_values() example
<?php
$array = array(1, "hello", 1, "world", "hello");
print_r(array_count_values($array));
?>
The above example will output:
Array
(
[1] => 2
[hello] => 2
[world] => 1
)
(PHP 4 >= 4.0.1, PHP 5, PHP 7, PHP 8)
array_diff — Computes the difference of arrays
array_diff(array $array, array ...$arrays): array
Compares
array
against one or more other arrays and returns the values in
array
that are not present in any of the other arrays.
array
The array to compare from
arrays
Arrays to compare against
Returns an
array
containing all the entries from
array
that are not present in any of the other arrays. Keys in the
array
array are preserved.
| Version | Description |
|---|---|
| 8.0.0 | This function can now be called with only one parameter. Formerly, at least two parameters have been required. |
Example #1 array_diff() example
<?php
$array1 = array("a" => "green", "red", "blue", "red");
$array2 = array("b" => "green", "yellow", "red");
$result = array_diff($array1, $array2);
print_r($result);
?>
Multiple occurrences in $array1 are all treated the same way. This will output :
Array
(
[1] => blue
)
Example #2 array_diff() example with non-matching types
Two elements are considered equal if and only if
(string) $elem1 === (string) $elem2
. That is, when the string representation is the same.
<?php
// This will generate a Notice that an array cannot be cast to a string.
$source = [1, 2, 3, 4];
$filter = [3, 4, [5], 6];
$result = array_diff($source, $filter);
// Whereas this is fine, since the objects can cast to a string.
class S {
private $v;
public function __construct(string $v) {
$this->v = $v;
}
public function __toString() {
return $this->v;
}
}
$source = [new S('a'), new S('b'), new S('c')];
$filter = [new S('b'), new S('c'), new S('d')];
$result = array_diff($source, $filter);
// $result now contains one instance of S('a');
?>
To use an alternate comparison function, see array_udiff() .
Note :
This function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using
array_diff($array1[0], $array2[0]);.
(PHP 4 >= 4.3.0, PHP 5, PHP 7, PHP 8)
array_diff_assoc — Computes the difference of arrays with additional index check
array_diff_assoc(array $array, array ...$arrays): array
Compares
array
against
arrays
and returns the difference. Unlike
array_diff()
the array keys are also used in the comparison.
array
The array to compare from
arrays
Arrays to compare against
Returns an
array
containing all the values from
array
that are not present in any of the other arrays.
| Version | Description |
|---|---|
| 8.0.0 | This function can now be called with only one parameter. Formerly, at least two parameters have been required. |
Example #1 array_diff_assoc() example
In this example you see the
"a" => "green"
pair is present in both arrays and thus it is not in the output from the function. Unlike this, the pair
0 => "red"
is in the output because in the second argument
"red"
has key which is
1
.
<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
The above example will output:
Array
(
[b] => brown
[c] => blue
[0] => red
)
Example #2 array_diff_assoc() example
Two values from
key => value
pairs are considered equal only if
(string) $elem1 === (string)
$elem2
. In other words a strict check takes place so the string representations must be the same.
<?php
$array1 = array(0, 1, 2);
$array2 = array("00", "01", "2");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
The above example will output:
Array
(
[0] => 0
[1] => 1
)
Note : This function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using, for example,
array_diff_assoc($array1[0], $array2[0]);.
Note : Ensure you pass arguments in the correct order when comparing similar arrays with more keys. The new array should be the first in the list.
(PHP 5 >= 5.1.0, PHP 7, PHP 8)
array_diff_key — Computes the difference of arrays using keys for comparison
array_diff_key(array $array, array ...$arrays): array
Compares the keys from
array
against the keys from
arrays
and returns the difference. This function is like
array_diff()
except the comparison is done on the keys instead of the values.
array
The array to compare from
arrays
Arrays to compare against
Returns an
array
containing all the entries from
array
whose keys are absent from all of the other arrays.
| Version | Description |
|---|---|
| 8.0.0 | This function can now be called with only one parameter. Formerly, at least two parameters have been required. |
Example #1 array_diff_key() example
The two keys from the
key => value
pairs are considered equal only if
(string) $key1 === (string) $key2
. In other words a strict type check is executed so the string representation must be the same.
<?php
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'yellow' => 7, 'cyan' => 8);
var_dump(array_diff_key($array1, $array2));
?>
The above example will output:
array(3) {
["blue"]=>
int(1)
["red"]=>
int(2)
["purple"]=>
int(4)
}
<?php
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'yellow' => 7, 'cyan' => 8);
$array3 = array('blue' => 6, 'yellow' => 7, 'mauve' => 8);
var_dump(array_diff_key($array1, $array2, $array3));
?>
The above example will output:
array(2) {
["red"]=>
int(2)
["purple"]=>
int(4)
}
Note :
This function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using
array_diff_key($array1[0], $array2[0]);.