Does array_diff_uassoc() preserve the key order of the original array?

M66 2025-06-06

In PHP, array_diff_uassoc() is a very useful array function that calculates the difference between two arrays, and also allows users to use custom comparison functions to compare keys of arrays. Many developers often have a question when using this function: Will array_diff_uassoc() retain the key order of the original array?

To answer this question, we first need to understand the basic usage of array_diff_uassoc() and its behavior.

Introduction to array_diff_uassoc() function

The array_diff_uassoc() function is used to calculate the difference between two arrays, similar to array_diff() , but unlike it, array_diff_uassoc() compares the keys and values of the array at the same time. Its function prototype is as follows:

 array array_diff_uassoc ( array $array1 , array $array2 , callable $key_compare_func )

$array1 : This is the first array, which will be compared with other arrays.
$array2 : This is the array that needs to be compared, usually one or more arrays.
$key_compare_func : This is a custom callback function that compares the keys of two array elements. The function should accept two keys as arguments and return a comparison result.

Keep key order?

Going back to the core of the question, will the key order of the original array be preserved when using array_diff_uassoc() ?

The answer is: Yes, array_diff_uassoc() will preserve the key order of the original array . When performing an array difference operation, array_diff_uassoc() will iterate over the first array ( $array1 ) and return elements that do not exist in the second array in the original key order. That is, the key order in $array1 will not be disrupted.

Example

We can demonstrate this with the following example:

 <?php
$array1 = [
    0 => 'a',
    1 => 'b',
    2 => 'c',
    3 => 'd'
];

$array2 = [
    0 => 'a',
    2 => 'c'
];

$result = array_diff_uassoc($array1, $array2, 'strcasecmp');

print_r($result);
?>

Output:

 Array
(
    [1] => b
    [3] => d
)

As shown above, the array_diff_uassoc() function successfully retains the order of keys 1 and 3 in the $array1 array and returns those elements that do not exist in $array2 . This shows that the key order of the original array has not changed.

Why is the key order preserved?

This is because the implementation of array_diff_uassoc() is based on the array_diff() function of PHP. The array returned by the array_diff() function is arranged in the order of the first array (i.e. $array1 ), and array_diff_uassoc() adds the key comparison function on this basis. Therefore, it naturally preserves the key order of the original array.

Things to note

Although array_diff_uassoc() retains the key order of the original array, we still need to pay attention to the following points:

If the elements in the second array ( $array2 ) contain the same keys as in the first array, then these elements are removed from the difference result, regardless of their position in the second array.
If you need to sort the result array, PHP provides multiple functions such as ksort() or asort() to sort the results according to your needs.

in conclusion

When using array_diff_uassoc() , the key order of the original array is preserved. This is useful for situations where you need to ensure that the key order is not messed up, especially when dealing with multi-dimensional arrays or associative arrays that need to maintain some order.

array_diff_uassoc