array_intersect_key

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

array_intersect_key — Karşılaştırma için anahtarları kullanarak dizilerin kesişimini hesaplar

Açıklama

array_intersect_key(array $dizi, array ...$diziler): array

array_intersect_key() işlevi dizi dizisinin tüm bağımsız değişkenlerde mevcut anahtarlarından oluşan bir ilişkisel dizi döndürür.

Bağımsız Değişkenler

dizi: Diğer dizilerin karşılaştırılacağı ilk dizi.
diziler: Anahtarları karşılaştırılacak diziler.

Dönen Değerler

dizi dizisinin tüm bağımsız değişkenlerde mevcut anahtarlarından oluşan bir ilişkisel dizi döndürür.

Sürüm Bilgisi

Sürüm:	Açıklama
8.0.0	Bu işlev artık yalnızca tek bir bağımsız değişken ile çağrılabiliyor. Evvelve en az iki bağımsız değişken gerekirdi.

Örnekler

Örnek 1 - array_intersect_key() örneği

<?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));
?>

Yukarıdaki örneğin çıktısı:

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

Örnekte gördüğünüz gibi her iki dizide de sadece 'blue' ve 'green' anahtarları ortak olduğundan dönen dizi sadece bu elemanları içermektedir. Ayrıca, dizilerde 'blue' ve 'green' anahtarlı elemanların değerlerinin farklı oluşuna da dikkat ediniz. Sadece anahtarlara bakıldığından bir eşleşme oluşmakta ve sadece dizi dizisindeki değerler döndürülmektedir.

İki anahtarın eşit olması için sadece ve sadece (string) $anahtar1 === (string) $anahtar2 olmalıdır. Başka bir deyişle, anahtarların dizgesel gösterimleri aynı olmalıdır.

Ayrıca Bakınız

array_diff() - Dizilerin farkını hesaplar
array_udiff() - Veri karşılaştırması için bir geriçağırım işlevi kullanarak diziler arasındaki farkı bulur
array_diff_assoc() - Dizilerin farkını hesaplarken ek olarak indisleri de karşılaştırır
array_diff_uassoc() - Dizilerin farkını hesaplarken ek olarak bir geriçağırım işlevi üzerinden indisleri de karşılaştırır
array_udiff_assoc() - Veri karşılaştırması için bir geriçağırım işlevi kullanarak diziler arasındaki farkı indislerine de bakarak bulur
array_udiff_uassoc() - Veri ve indis karşılaştırması için bir geriçağırım işlevi kullanarak diziler arasındaki farkı indislerine de bakarak bulur
array_diff_key() - Dizilerin farkını hesaplarken indisleri karşılaştırır
array_diff_ukey() - Karşılaştırma için bir geriçağırım işlevi kullanarak dizilerin farkını hesaplar
array_intersect() - Dizilerin kesişimini hesaplar
array_intersect_assoc() - Dizilerin kesişimini hesaplarken ek olarak indisleri de karşılaştırır
array_intersect_uassoc() - Dizilerin kesişimini hesaplarken ek olarak bir geriçağırım işlevi üzerinden indisleri de karşılaştırır
array_intersect_ukey() - Anahtarları karşılaştırmak için bir geriçağırım işlevi kullanarak dizilerin kesişimini hesaplar

add a note

User Contributed Notes 11 notes

down

265

vladas dot dirzys at gmail dot com ¶

12 years 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

)

down

Anonymous ¶

3 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.

To sort by the second array, then you may do so through array_replace.

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

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

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

?>

Shows:

Array
(
    [one] => c
    [three] => b
)

Rather than:

Array
(
    [three] => b
    [one] => c
)

down

github.com/xmarcos ¶

10 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.



<?php



$defaults = [

    '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

    ]

];



var_dump(

    array_replace_recursive($defaults, 

        array_intersect_key(

            $options, $defaults

        )

    )

);



?>



Output:



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

down

Reed Silver ¶

9 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;

down

pgl at yoyo dot org ¶

13 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
)

down

CBWhiz at gmail dot com ¶

16 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)
}

?>

down

Anton Backer ¶

18 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.

down

chrisbloom7 at gmail dot com ¶

15 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";
?>

down

markus dot kappe at dix dot at ¶

15 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;
    }
?>

down

-2

pixelf3hler at visualize-me dot de ¶

11 years 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
?>

down

-4

pdemaziere at gmail dot com ¶

15 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!

add a note