La función array_udiff_assoc() de PHP explicada

array_udiff_assoc() compara dos o más arrays y devuelve las entradas del primer array que no aparecen en ninguno de los demás. Lo que la hace especial es cómo compara: las claves se comparan con verificación estricta integrada, mientras que los valores se comparan mediante una función de callback que tú proporcionas. Esta página explica la firma, recorre ejemplos funcionales (strings, múltiples arrays y objetos) y cubre los errores frecuentes que confunden a los desarrolladores.

Sintaxis

array_udiff_assoc(
    array $array,
    array ...$arrays,
    callable $value_compare_func
): array

• $array — el array a comparar desde. Solo sus entradas pueden aparecer en el resultado.
• ...$arrays — uno o más arrays con los que comparar contra. Puedes pasar tantos como quieras.
• $value_compare_func — un callback que compara dos valores. Debe devolver un entero menor que, igual a, o mayor que 0 cuando el primer argumento se considera respectivamente menor que, igual a, o mayor que el segundo — el mismo contrato usado por usort() y el operador nave espacial (<=>).

Devuelve un nuevo array con los pares clave/valor que sobreviven de $array. El callback es siempre el último argumento.

Cómo funciona la comparación

Una entrada del primer array se mantiene a menos que otro array tenga tanto la misma clave (comparada internamente como string) como un valor que el callback reporta como igual (devuelve 0). En otras palabras:

• Claves → comparación estricta e integrada (el assoc en el nombre).
• Valores → tu callback (la u, de user-defined, definida por el usuario).

Esta es la diferencia clave respecto a array_diff_assoc(), que compara valores con conversión a (string), y respecto a array_udiff(), que ignora las claves por completo.

Ejemplo básico

<?php

function compareArrays($a, $b) {
  if ($a === $b) {
    return 0;
  }
  return ($a > $b) ? 1 : -1;
}

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

$result = array_udiff_assoc($array1, $array2, "compareArrays");

print_r($result);

?>

Analizando clave por clave:

• a → "red" vs "red": las claves coinciden, el callback devuelve 0 (igual) → eliminado.
• b → "green" vs "blue": las claves coinciden, los valores difieren → conservado.
• c → "blue" vs "green": las claves coinciden, los valores difieren → conservado.

Así que la salida es:

Array
(
    [b] => green
    [c] => blue
)

Comparación contra varios arrays

Puedes pasar más de un array para comparar. Una entrada sobrevive solo si está ausente en todos los demás arrays. Aquí el callback compara strings por longitud primero y luego alfabéticamente:

<?php

function compareValues($a, $b) {
  return strlen($a) <=> strlen($b) ?: strcmp($a, $b);
}

$current  = ["item1" => "apple", "item2" => "banana", "item3" => "kiwi"];
$baseline = ["item1" => "apple", "item2" => "cherry", "item3" => "kiwi"];

$result = array_udiff_assoc($current, $baseline, "compareValues");

print_r($result);

// Array
// (
//     [item2] => banana
// )

Solo item2 difiere: "banana" (6 letras) y "cherry" (6 letras) tienen la misma longitud, por lo que el callback recurre a strcmp(), que los reporta como distintos. item1 e item3 son idénticos en ambos arrays y se eliminan.

Comparación de objetos

La verdadera potencia de array_udiff_assoc() se muestra cuando los valores son objetos o arrays — cosas que no puedes comparar con una simple conversión a string. El callback decide qué significa "igual". Aquí se comparan dos carritos por precio únicamente, ignorando el nombre del producto:

<?php

class Product {
  public function __construct(public string $name, public float $price) {}
}

function byPrice(Product $a, Product $b): int {
  return $a->price <=> $b->price;
}

$cart = [
  "p1" => new Product("Pen", 1.50),
  "p2" => new Product("Notebook", 3.00),
];

$reference = [
  "p1" => new Product("Pen", 1.50),
  "p2" => new Product("Notebook", 4.25),
];

$diff = array_udiff_assoc($cart, $reference, "byPrice");

foreach ($diff as $key => $product) {
  echo "$key => {$product->name} ({$product->price})\n";
}

// p2 => Notebook (3)

p1 tiene el mismo precio en ambos carritos y se elimina; el precio de p2 cambió, por lo que sobrevive.

Casos especiales

• El callback es el último argumento, no el segundo. Un error habitual es llamar a array_udiff_assoc($a, $callback, $b). El orden siempre es: primer array, luego los arrays con los que comparar, y finalmente el callback.
• El callback compara valores, no claves. Las claves se manejan internamente con comparación estricta; no puedes influir en la coincidencia de claves aquí. Si necesitas una comparación de claves personalizada también, usa array_udiff_uassoc().
• Devuelve un entero, no un boolean. Devolver true/false desde el callback funciona por casualidad (se convierten a 1/0) pero es frágil — devuelve el resultado de <=> o un -1/0/1 explícito.
• El resultado conserva las claves originales del primer array; no reindexará.

Cuándo usarla

Recurre a array_udiff_assoc() cuando tanto la clave como una comparación de valores personalizada importan — por ejemplo, comparando dos conjuntos de datos con clave de objetos, comparando registros sin distinguir mayúsculas mientras se mantienen sus identificadores, o calculando qué cambió entre un estado anterior y el actual. Si las claves no importan, usa array_udiff(); si tus valores son escalares simples, la más ligera array_diff_assoc() suele ser suficiente.

Conclusión

array_udiff_assoc() es una herramienta precisa para encontrar diferencias entre arrays cuando tanto las claves como la lógica de comparación de valores personalizada importan. Al combinar la coincidencia estricta de claves con un callback de comparación que tú controlas, puedes comparar estructuras de datos complejas — objetos, arrays anidados, strings normalizados — sin escribir bucles anidados ni comprobaciones manuales.

Práctica