PHP 5.6.0beta1 released

array_intersect_key

(PHP 5 >= 5.1.0)

array_intersect_keyComputes the intersection of arrays using keys for comparison

Description

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

array_intersect_key() returns an array containing all the entries of array1 which have keys that are present in all the arguments.

Parameters

array1

The array with master keys to check.

array2

An array to compare keys against.

array

A variable list of arrays to compare.

Return Values

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

Examples

Example #1 array_intersect_key() example

<?php
$array1 
= array('blue'  => 1'red'  => 2'green'  => 3'purple' => 4);
$array2 = array('green' => 5'blue' => 6'yellow' => 7'cyan'   => 8);

var_dump(array_intersect_key($array1$array2));
?>

The above example will output:

array(2) {
  ["blue"]=>
  int(1)
  ["green"]=>
  int(3)
}

In our example you see that only the keys 'blue' and 'green' are present in both arrays and thus returned. Also notice that the values for the keys 'blue' and 'green' differ between the two arrays. A match still occurs because only the keys are checked. The values returned are those of array1.

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.

See Also

  • array_diff() - تفاوت آرایه‌ها را محاسبه می‌کند
  • array_udiff() - Computes the difference of arrays by using a callback function for data comparison
  • array_diff_assoc() - تفاوت آرایه‌ها با استفاده از بررسی اندیس اضافه محاسبه می‌کند
  • array_diff_uassoc() - Computes the difference of arrays with additional index check which is performed by a user supplied callback function
  • 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_diff_key() - تفاوت آرایه‌ها را با استفاده از مقایسه کلیدها محاسبه می‌کند
  • array_diff_ukey() - Computes the difference of arrays using a callback function on the keys for comparison
  • array_intersect() - Computes the intersection of arrays
  • array_intersect_assoc() - Computes the intersection of arrays with additional index check
  • 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

add a note add a note

User Contributed Notes 11 notes

up
23
vladas dot dirzys at gmail dot com
1 year ago
Simple key white-list filter:

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

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

Will return:
Array
(
    [b] => 213
    [c] => 321
)
up
2
CBWhiz at gmail dot com
6 years ago
I have found the following helpful:
<?PHP
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.

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

array(
2) {
  [
"two"]=>
 
int(2)
  [
"one"]=>
 
int(42)
}

?>
up
1
pixelf3hler at visualize-me dot de
6 months ago
in case you came here looking for a function that returns an array containing the values of `all` arrays with intersecting keys:
<?php
  
function array_merge_on_key($key, $array1, $array2) {
     
$arrays = array_slice(func_get_args(), 1);
     
$r = array();
      foreach(
$arrays as &$a) {
         if(
array_key_exists($key, $a)) {
           
$r[] = $a[$key];
            continue;
         }
      }
      return
$r;
   }
  
// 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);

   echo
implode(",", $result); // => 12,4,9,10
?>
up
0
chrisbloom7 at gmail dot com
4 years ago
Regarding php at keithtylerdotcom solution to emulate

<?php
$z
= 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:

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

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

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

//better one line method
$b = implode('', array_intersect_key(someFuncReturningAnArray(), array('a'=>'')));
echo
print_r($b, 1) . "\n----------\n";
?>
up
0
pdemaziere at gmail dot com
5 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.

<?php
$outcome
= 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.

Enjoy!
up
0
Anonymous
7 years ago
Here it is a more obvious way to implement the function:

if (!function_exists('array_intersect_key')) {
    function array_intersect_key()
    {
        $arrs = func_get_args();
        $result = array_shift($arrs);
        foreach ($arrs as $array) {
            foreach ($result as $key => $v) {
                if (!array_key_exists($key, $array)) {
                    unset($result[$key]);
                }
            }
        }
        return $result;
   }
}
up
0
Anton Backer
8 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.
up
0
aidan at php dot net
8 years ago
This functionality is now implemented in the PEAR package PHP_Compat.

More information about using this function without upgrading your version of PHP can be found on the below link:

http://pear.php.net/package/PHP_Compat
up
-1
Rod Byrnes
6 years ago
Here is a faster version than those shown below, with optimisation for the case when only two arrays are passed. In my tests with a 10000 item first array and a 5000 item second array (run 20 times) this function ran in 1.89 seconds compared with 2.66 for the version posted by dak. For a three array case, same as above but with the third array containing 3333 values, the timing is 3.25 for this version compared with 3.7 for dak's version.

<?php
if (!function_exists('array_intersect_key'))
{
  function
array_intersect_key($isec, $keys)
  {
   
$argc = func_num_args();
    if (
$argc > 2)
    {
      for (
$i = 1; !empty($isec) && $i < $argc; $i++)
      {
       
$arr = func_get_arg($i);
        foreach (
array_keys($isec) as $key)
        {
          if (!isset(
$arr[$key]))
          {
            unset(
$isec[$key]);
          }
        }
      }
      return
$isec;
    }
    else
    {
     
$res = array();
      foreach (
array_keys($isec) as $key)
      {
        if (isset(
$keys[$key]))
        {
         
$res[$key] = $isec[$key];
        }
      }
      return
$res;
    }
  }
}
?>
up
-1
pgl at yoyo dot org
2 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:

<?php
$array
= array(
   
'two'   => 'a',
   
'three' => 'b',
   
'one'   => 'c',
    );

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

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

?>

Shows:

Array
(
    [three] => b
    [one] => c
)
up
-1
markus dot kappe at dix dot at
4 years ago
<?php
   
/**
     * 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
       
}
        return
$master;
    }
?>
To Top