PHP 8.1.0 Alpha 1 available for testing


(PHP 5 >= 5.1.0, PHP 7, PHP 8)

array_intersect_keyCalcule l'intersection de deux tableaux en utilisant les clés pour comparaison


array_intersect_key ( array $array , array ...$arrays ) : array

array_intersect_key() retourne un tableau contenant toutes les entrées du tableau array qui contiennent des clés présentes dans tous les tableaux passés en arguments.

Liste de paramètres


Le tableau contenant les clés maîtresses à vérifier.


Tableaux à comparer contre

Valeurs de retour

Retourne un tableau associatif contenant toutes les entrées du tableau array dont les clés sont présentes dans tous les arguments.


Exemple #1 Exemple avec array_intersect_key()

= array('bleu'  => 1'rouge'  => 2'vert'  => 3'violet' => 4);
$array2 = array('vert' => 5'bleu' => 6'jaune' => 7'cyan'   => 8);


L'exemple ci-dessus va afficher :

array(2) {

Dans cet exemple, vous pouvez voir que seules les clés 'bleu' et 'vert' sont présentes dans les deux tableaux et donc, elles sont retournées. Notez également que les valeurs pour les clés 'bleu' et 'vert' diffèrent entre les deux tableaux. Néanmoins, elles correspondent toujours car uniquement les clés sont vérifiées. Les valeurs retournées sont celles du tableau array1.

Les deux clés depuis les paires clé => valeur sont considérées comme égales uniquement si (string) $cle1 === (string) $cle2 . En d'autres mots, une analyse stricte du type est exécutée, donc la représentation sous forme de chaine doit être exactement la même.

Voir aussi

  • array_diff() - Calcule la différence entre des tableaux
  • array_udiff() - Calcule la différence entre deux tableaux en utilisant une fonction rappel
  • array_diff_assoc() - Calcule la différence de deux tableaux, en prenant aussi en compte les clés
  • array_diff_uassoc() - Calcule la différence entre deux tableaux associatifs, à l'aide d'une fonction de rappel
  • array_udiff_assoc() - Calcule la différence entre des tableaux avec vérification des index, compare les données avec une fonction de rappel
  • array_udiff_uassoc() - Calcule la différence de deux tableaux associatifs, compare les données et les index avec une fonction de rappel
  • array_diff_key() - Calcule la différence de deux tableaux en utilisant les clés pour comparaison
  • array_diff_ukey() - Calcule la différence entre deux tableaux en utilisant une fonction de rappel sur les clés pour comparaison
  • array_intersect() - Calcule l'intersection de tableaux
  • array_intersect_assoc() - Calcule l'intersection de deux tableaux avec des tests sur les index
  • array_intersect_uassoc() - Calcule l'intersection de deux tableaux avec des tests sur les index, compare les index en utilisant une fonction de rappel
  • array_intersect_ukey() - Calcule l'intersection de deux tableaux en utilisant une fonction de rappel sur les clés pour comparaison

add a note add a note

User Contributed Notes 10 notes

vladas dot dirzys at gmail dot com
8 years ago
Simple key white-list filter:

= array('a' => 123, 'b' => 213, 'c' => 321);
$allowed = array('b', 'c');

print_r(array_intersect_key($arr, array_flip($allowed)));

Will return:
    [b] => 213
    [c] => 321
7 years ago
[Editor's note: changed array_merge_recursive() to array_replace_recursive() to fix the script]

Here is a better way to merge settings using some defaults as a whitelist.


= [
'id'            => 123456,
'client_id'     => null,
'client_secret' => null,
'options'       => [
'trusted' => false,
'active'  => false

$options = [
'client_id'       => 789,
'client_secret'   => '5ebe2294ecd0e0f08eab7690d2a6ee69',
'client_password' => '5f4dcc3b5aa765d61d8327deb882cf99', // ignored
'client_name'     => 'IGNORED',                          // ignored
'options'         => [
'active' => true

$options, $defaults



array (size=4)
    'id'            => int 123456
    'client_id'     => int 789
    'client_secret' => string '5ebe2294ecd0e0f08eab7690d2a6ee69' (length=32)
    'options'       =>
        array (size=2)
            'trusted' => boolean false
            'active'  => boolean true
pgl at yoyo dot org
9 years ago
Note that the order of the keys in the returned array is the same as the order of the keys in the source array. eg:

= array(
'two'   => 'a',
'three' => 'b',
'one'   => 'c',

$keyswant = array(
'one'       => '',
'three'     => '',

print_r(array_intersect_key($array, $keyswant));



    [three] => b
    [one] => c
chrisbloom7 at gmail dot com
11 years ago
Regarding php at keithtylerdotcom solution to emulate

= someFuncReturningAnArray()['some_key'];

His recommended solution will still return an array. To get the value of a single key in an array returned by a function, simply add implode() to the recipe:

function someFuncReturningAnArray() {
  return array(
'a' => 'b',
'c' => 'd',
'e' => 'f',
'g' => 'h',
'i' => 'j'

//traditional way
$temp = someFuncReturningAnArray();
$b = $temp['a'];
print_r($b, 1) . "\n----------\n";

//keithtylerdotcom one-line method
$b = array_intersect_key(someFuncReturningAnArray(), array('a'=>''));
print_r($b, 1) . "\n----------\n";

//better one line method
$b = implode('', array_intersect_key(someFuncReturningAnArray(), array('a'=>'')));
print_r($b, 1) . "\n----------\n";
Anton Backer
15 years ago
Jesse: no, array_intersect_key does not accomplish the same thing as what you posted:

array_flip (array_intersect (array_flip ($a), array_flip ($b)))

because when the array is flipped, values become keys. having duplicate values is not a problem, but having duplicate keys is. array_flip resolves it by keeping only one of the duplicates and discarding the rest. by the time you start intersecting, you've already lost information.
CBWhiz at gmail dot com
13 years ago
I have found the following helpful:
function array_merge_default($default, $data) {
$intersect = array_intersect_key($data, $default); //Get data for which a default exists
$diff = array_diff_key($default, $data); //Get defaults which are not present in data
return $diff + $intersect; //Arrays have different keys, return the union of the two
It's use is like both of the functions it uses, but keeps defaults and _only_ defaults. It's designed for key arrays, and i'm not sure how it will work on numeric indexed arrays.

= array(
"one" => 1,
"two" => 2
$untrusted = array(
"one" => 42,
"three" => 3
var_dump(array_merge_default($default, $untrusted));

2) {

Reed Silver
6 years ago
If you want an array that has no key value pairs added from the second array:

$new = array_intersect_key($b, $a) + $a;
markus dot kappe at dix dot at
11 years ago
     * calculates intersection of two arrays like array_intersect_key but recursive
     * @param  array/mixed  master array
     * @param  array        array that has the keys which should be kept in the master array
     * @return array/mixed  cleand master array
function myIntersect($master, $mask) {
        if (!
is_array($master)) { return $master; }
        foreach (
$master as $k=>$v) {
            if (!isset(
$mask[$k])) { unset ($master[$k]); continue; } // remove value from $master if the key is not present in $mask
if (is_array($mask[$k])) { $master[$k] = $this->myIntersect($master[$k], $mask[$k]); } // recurse when mask is an array
            // else simply keep value
pdemaziere at gmail dot com
12 years ago
Just a simple script if you want to use one array, which contains only zeros and ones, as mask for another one (both arrays must have the same size of course). $outcome is an array that contains only those values from $source where $mask is equal to 1.

= array_values(array_intersect_key( array_values($source), array_filter(array_values($mask)) ));

PS: the array_values() function is necessary to ensure that both arrays have the same numbering/keys, otherwise your masking does not behave as you expect.

pixelf3hler at visualize-me dot de
7 years ago
in case you came here looking for a function that returns an array containing the values of `all` arrays with intersecting keys:
function array_merge_on_key($key, $array1, $array2) {
$arrays = array_slice(func_get_args(), 1);
$r = array();
$arrays as &$a) {
array_key_exists($key, $a)) {
$r[] = $a[$key];
// example:
$array1 = array("id" => 12, "name" => "Karl");
$array2 = array("id" => 4, "name" => "Franz");
$array3 = array("id" => 9, "name" => "Helmut");
$array4 = array("id" => 10, "name" => "Kurt");

$result = array_merge_on_key("id", $array1, $array2, $array3, $array4);

implode(",", $result); // => 12,4,9,10
To Top