PHP 8.3.4 Released!

array_diff_key

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

array_diff_keyComputa a diferença entre arrays usando as chaves na comparação

Descrição

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

Compara as chaves do array com as chaves do arrays e retorna a diferença. Esta função é similar a array_diff(), com exceção que a comparação é feita com as chaves, ao invés dos valores.

Parâmetros

array

O array a ser comparado

arrays

Arrays para comparar

Valor Retornado

Retorna um array contendo todas as entradas de array cujas chaves não estão presentes em qualquer dos outros arrays.

Registro de Alterações

Versão Descrição
8.0.0 Esta função agora pode ser chamada com apenas um parâmetro. Anteriormente, pelo menos dois parâmetros eram necessários.

Exemplos

Exemplo #1 Exemplo da função array_diff_key()

As duas chaves dos pares chave => valor são consideradas iguais somente se (string) $key1 === (string) $key2 . Em outras palavras, uma checagem de tipo estrita é feita para que representações de string sejam as mesmas.

<?php
$array1
= array('azul' => 1, 'vermelho' => 2, 'verde' => 3, 'roxo' => 4);
$array2 = array('verde' => 5, 'amarelo' => 6, 'ciano' => 8);

var_dump(array_diff_key($array1, $array2));
?>

O exemplo acima produzirá:

array(3) {
  ["azul"]=>
  int(1)
  ["vermelho"]=>
  int(2)
  ["roxo"]=>
  int(4)
}
<?php
$array1
= array('azul' => 1, 'vermelho' => 2, 'verde' => 3, 'roxo' => 4);
$array2 = array('verde' => 5, 'amarelo' => 7, 'ciano' => 8);
$array3 = array('azul' => 6, 'amarelo' => 7, 'malva' => 8);

var_dump(array_diff_key($array1, $array2, $array3));
?>

O exemplo acima produzirá:

array(2) {
  ["vermelho"]=>
  int(2)
  ["roxo"]=>
  int(4)
}

Notas

Nota:

Essa função checa somente uma dimensão de um array n-dimensional. É claro que você pode checar dimensões mais profundas usando array_diff_key($array1[0], $array2[0]);.

Veja Também

  • array_diff() - Computa as diferenças entre arrays
  • array_udiff() - Computa a diferença de arrays usando uma função de callback para comparação dos dados
  • array_diff_assoc() - Computa a diferença entre arrays com checagem adicional de índice
  • array_diff_uassoc() - Computa a diferença entre arrays com checagem adicional de índice que feita por uma função de callback fornecida pelo usuário
  • array_udiff_assoc() - Computa a diferença entre arrays com checagem adicional de índice, compara dados por uma função de callback
  • array_udiff_uassoc() - Computa a diferença entre arrays com checagem adicional de índice, compara dados e índices por uma função de callback
  • array_diff_ukey() - Computa a diferença entre arrays usando uma função callback na comparação de chaves
  • array_intersect() - Calcula a interseção entre arrays
  • array_intersect_assoc() - Computa a interseção de arrays com uma adicional verificação de índice
  • array_intersect_uassoc() - Computa a interseção de arrays com checagem de índice adicional, compara índices por uma função de callback
  • array_intersect_key() - Calcula a interseção de arrays, comparando pelas chaves
  • array_intersect_ukey() - Computa a interseção de arrays usando uma função de callback nas chaves para comparação

add a note

User Contributed Notes 11 notes

up
17
Ashton
15 years ago
To return the unique elements (those with a key that exists only once in either array but not in both) try:
function array_unique_diff ($array1, $array2)
{
array_merge(array_diff_key($array1, $array2), array_diff_key($array2, $array1));
}

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

array_diff_key($array1, $array2)

returns

array ( 'red' => 2, 'purple' => 4 )

array_diff_key($array2, $array1)

returns

array ( 'yellow' => 7, 'cyan' => 8, )

array_unique_diff($array1, $array2);

returns

array ( 'red' => 2, 'purple' => 4, 'yellow' => 7, 'cyan' => 8, )
up
8
gk at anuary dot com
10 years ago
Improved recursive version.

<?php
/**
* @author Gajus Kuizinas <gk@anuary.com>
* @version 1.0.0 (2013 03 19)
*/
function array_diff_key_recursive (array $arr1, array $arr2) {
$diff = array_diff_key($arr1, $arr2);
$intersect = array_intersect_key($arr1, $arr2);

foreach (
$intersect as $k => $v) {
if (
is_array($arr1[$k]) && is_array($arr2[$k])) {
$d = array_diff_key_recursive($arr1[$k], $arr2[$k]);

if (
$d) {
$diff[$k] = $d;
}
}
}

return
$diff;
}
?>

An up to date version is maintained at https://github.com/gajus/flow/blob/master/flow.inc.php#L337.
up
7
sjungwirth at matrix-consultants dot com
16 years ago
I needed something a little different where maybe even the keys in multidimensional arrays don't match up. Setting $assoc to false will cause only to check for missing keys, otherwise it compares values as well. This was also based on '2ge at 2ge dot us' function

<?php

function n_array_diff_assoc ($a1, $a2, $assoc=true) {
$r = array();
if(
is_array(current($a1))):
foreach(
$a1 as $k => $v):
if(isset(
$a2[$k])):
$diff = n_array_diff($a1[$k], $a2[$k], $assoc);
if (!empty(
$diff)):
$r[$k] = $diff;
endif;
else:
$r[$k] = $v;
endif;
endforeach;
else:
$r = $assoc ? array_diff_assoc($a1, $a2) : array_diff_key($a1, $a2);
endif;
return
$r;
}
?>
up
5
maxence at pontapreta dot net
18 years ago
Seems to be a great function, especially for n-dimensions arrays. The only problem is that I cannot find it in php 5.0.3 and 5.0.4. Does it really exist ?! :(

[20:27:05][maxence@conurb] ~/test2/php-5.0.4$ grep PHP_FUNCTION * -r | grep -i array_diff_key
[20:27:09][maxence@conurb] ~/test2/php-5.0.4$
up
3
AiFiLTr0 [at host] invyl [dot] ath.cx
16 years ago
The recursive function suggested by '2ge at 2ge dot us' will provide you with empty arrays if there's no diff.
This variant of the function cleans up empty arrays and fixes a bug in the first suggested version. It works 100%
.
<?php
function array_diff_key_recursive ($a1, $a2) {
foreach(
$a1 as $k => $v) {
//$r[$k] = is_array($v) ? $this->array_diff_key_recursive($a1[$k], $a2[$k]) : array_diff_key($a1, $a2);
if (is_array($v))
{
$r[$k]=$this->array_diff_key_recursive($a1[$k], $a2[$k]);
}else
{
$r=array_diff_key($a1, $a2);
}

if (
is_array($r[$k]) && count($r[$k])==0)
{
unset(
$r[$k]);
}
}
return
$r;
}
?>
up
3
coder at gs dot com
16 years ago
The PHP4 version below works only unidirectionally. If you switch the arrays around i.e. (ar2, ar1) you get different results than (ar1, ar2).
up
0
ampf at egp dot up dot pt
18 years ago
Well, you could implement in the code something more powerfull:

http://www.php.net/manual/en/function.array-diff.php#31364
up
-1
rhallsey at yahoo dot com
9 years ago
Here's a simple function that returns true if all keys in the first array are found in the second array, and false if they aren't.

function same_keys ($a1, $a2) {
$same = false;
if (!array_diff_key($a1, $a2)) {
$same = true;
foreach ($a1 as $k => $v) {
if (is_array($v) && !same_keys($v, $a2[$k])) {
$same = false;
break;
}
}
}
return $same;
}

To check if two arrays have the same structure, ignoring values, execute the function twice, the second time with the arguments reversed.
up
-2
division-par-zero at zilon dot net
15 years ago
you can use this function for return the difference of two array !

<?php
function array_unique_diff_key ($array1, $array2)
{
if (
is_array($array1) && is_array($array2))
return
array_diff_key($array1, $array2) + array_diff_key($array2, $array1);
else if (
is_array($array1)) return $array1;
else if (
is_array($array2)) return $array2;
else return array();
}
?>
up
-3
vlad_mustafin at ukr dot net
18 years ago
One more alternative variant :)
<?
if (!function_exists('array_diff_key')) {
function array_diff_key() {
$argCount = func_num_args();
$diff_arg_prefix = 'diffArg';
$diff_arg_names = array();
for ($i=0; $i < $argCount; $i++) {
$diff_arg_names[$i] = 'diffArg'.$i;
$$diff_arg_names[$i] = array_keys((array)func_get_arg($i));
}
$diffArrString = '';
if (!empty($diff_arg_names)) $diffArrString = '$'.implode(', $', $diff_arg_names);
eval("\$result = array_diff(".$diffArrString.");");
return $result;
}
}
?>
up
-6
2ge at 2ge dot us
18 years ago
Hello, if you need diff key of n-dimensional arrays here is nice solution:
<?php
function n_array_diff ($a1, $a2) {
foreach(
$a1 as $k => $v) {
$r[$k] = is_array($v) ? n_array_diff($a1[$k], $a2[$k]) : array_diff_key($a1, $a2);
}
return
$r;
}
?>
it will print everything, what is missing in $a2.
To Top