Função PHP array_diff_assoc

A função PHP array_diff_assoc() compara dois ou mais arrays e retorna as entradas do primeiro array que estão ausentes em todos os outros. Ao contrário de array_diff(), que verifica apenas os valores, array_diff_assoc() verifica tanto a chave quanto o valor — portanto, um par sobrevive à comparação somente quando nenhum outro array possui essa chave exata emparelhada com esse valor exato. Isso a torna a ferramenta ideal para comparar arrays associativos.

Esta página aborda a sintaxe, como funciona a correspondência de chave + valor, a diferença em relação a array_diff(), o detalhe da comparação solta (string) e um exemplo com múltiplos arrays.

Sintaxe

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

• $array — o array a partir do qual a comparação é feita. As entradas que sobrevivem formam o resultado.
• ...$arrays — um ou mais arrays para comparar.

A função retorna um novo array contendo todos os pares chave/valor de $array que não aparecem (com a mesma chave) em nenhum dos outros arrays. As chaves são preservadas no resultado.

Como funciona

array_diff_assoc() percorre o primeiro array e, para cada par, pergunta: algum outro array possui essa mesma chave com esse mesmo valor? Se sim, o par é removido; se não, ele é mantido.

Exemplo de array_diff_assoc() em PHP

Saída:

Array
(
    [b] => banana
)

Apenas "b" => "banana" sobrevive: $array2 não possui a chave b. Os pares a e c coincidem tanto pela chave quanto pelo valor, por isso são removidos. Note que "d" => "date" em $array2 é irrelevante — somente entradas do primeiro array podem aparecer no resultado.

array_diff_assoc() vs array_diff()

A principal diferença é se as chaves fazem parte da comparação. Com o mesmo valor sob chaves diferentes, array_diff() os considera iguais, mas array_diff_assoc() não:

<?php

$a = array("a" => "apple", "b" => "banana");
$b = array("x" => "apple");

print_r(array_diff_assoc($a, $b)); // compares key AND value
print_r(array_diff($a, $b));       // compares value only

?>

Saída:

Array
(
    [a] => apple
    [b] => banana
)
Array
(
    [b] => banana
)

array_diff_assoc() mantém "a" => "apple" porque $b armazena apple sob a chave x, não a. array_diff() o remove porque o valor apple existe em algum lugar de $b.

Detalhe: a comparação é feita como strings

Internamente, array_diff_assoc() compara valores de forma solta, convertendo-os para string — (string) $elem1 === (string) $elem2. Isso significa que 10 (int) e "10" (string) são considerados iguais:

<?php

$a = array("x" => 10);
$b = array("x" => "10");

print_r(array_diff_assoc($a, $b));

?>

Saída:

Array
(
)

O resultado é vazio: 10 e "10" se convertem para a mesma string "10". Se você precisar de uma comparação estrita com atenção ao tipo, use um callback com array_udiff_assoc() (ou compare os tipos manualmente). Para comparar apenas pelas chaves, use array_diff_key().

Comparando mais de dois arrays

Você pode passar qualquer número de arrays. Uma entrada deve estar ausente em todos eles para sobreviver. Isso também funciona com chaves numéricas:

<?php

$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");

print_r(array_diff_assoc($array1, $array2));

?>

Saída:

Array
(
    [b] => brown
    [c] => blue
    [0] => red
)

"a" => "green" coincide e é removido. [0] => "red" sobrevive porque em $array2 o valor "red" está na chave 1, não 0 — portanto o par chave/valor é diferente.

Quando usar

• Para comparar dois arrays de configuração onde a chave importa (por exemplo, identificar opções alteradas).
• Para encontrar entradas removidas de um instantâneo "antes" quando tanto a identidade da chave quanto a do valor importam.
• Em qualquer comparação onde corresponder apenas pelo valor (array_diff()) geraria falsos positivos.

Funções relacionadas

• array_diff() — compara somente pelo valor.
• array_diff_key() — compara somente pela chave.
• array_intersect_assoc() — o inverso: mantém as entradas presentes em todos os arrays por chave e valor.

Prática