array_diff_key

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

array_diff_key — Computa 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:
Esta função verifica somente uma dimensão de um array n-dimensional. É claro que as dimensões mais profundas podem ser verificadas 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 verificação adicional de índice, comparando dados por uma função de retorno
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 retorno nas chaves para comparação

Melhore Esta Página

Aprenda Como Melhorar Esta Página • Envie uma Solicitação de Modificação • Reporte um Problema

＋adicione uma nota

Notas Enviadas por Usuários (em inglês) 10 notes

down

Ashton ¶

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

down

gk at anuary dot com ¶

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

down

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

down

maxence at pontapreta dot net ¶

19 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$

down

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

down

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

down

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

down

-1

rhallsey at yahoo dot com ¶

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

down

-2

division-par-zero at zilon dot net ¶

16 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();

}

?>

down

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

＋adicione uma nota