Can array_diff_uassoc() handle multidimensional arrays?

M66 2025-06-06

In PHP, array_diff_uassoc() is a function used to compare the differences in key names and key values of two or more arrays. It not only compares the values of the array, but also compares the keys of the array based on user-defined callback functions. When dealing with single-dimensional arrays, array_diff_uassoc() is relatively simple to use, but when dealing with multi-dimensional arrays, how can we use it to achieve key-value difference comparison? This article will answer this question and provide a practical example.

Basic usage of array_diff_uassoc() function

First, let's review the basic usage of array_diff_uassoc() . Its syntax is as follows:

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

Parameter description:

array1 : The first array to be compared.
array2 : The second array to be compared with the first array.
key_compare_func : a user-defined callback function used to compare the keys of two arrays. The function must return an integer representing the result of the comparison of two keys.

Return value:

Returns an array containing the differential elements, i.e. a key-value pair that exists in array1 but is not in array2 .

Example:

 function compare_keys($key1, $key2) {
    return strcasecmp($key1, $key2);
}

$array1 = [
    'a' => 'apple',
    'b' => 'banana',
    'c' => 'cherry'
];

$array2 = [
    'A' => 'apple',
    'B' => 'banana',
    'd' => 'date'
];

$result = array_diff_uassoc($array1, $array2, 'compare_keys');
print_r($result);

Output:

 Array
(
    [c] => cherry
)

As shown above, array_diff_uassoc() compares the keys of the array, and will determine whether the two keys are equal based on the callback function compare_keys() .

How to deal with multidimensional arrays?

For multidimensional arrays, we may need to compare not only the top-level keys, but also the keys of nested arrays. In this case, array_diff_uassoc() cannot be used directly in multidimensional arrays. We need to do some extra work to handle this situation.

Implementation ideas:

Recursively traverse multidimensional arrays : Since multidimensional arrays are nested structures, we can use recursive methods to process each layer of array.
Comparison of key values using custom callback functions : During the recursion process, we can define a callback function for the key value difference comparison of each layer of array.

Sample code: Implementing the comparison of key-value differences between multidimensional arrays

 function compare_keys($key1, $key2) {
    return strcasecmp($key1, $key2);
}

function recursive_array_diff_uassoc($array1, $array2, $key_compare_func) {
    $result = [];
    
    foreach ($array1 as $key => $value) {
        // If the current value is an array，Recursive call
        if (is_array($value)) {
            $sub_result = recursive_array_diff_uassoc($value, $array2[$key] ?? [], $key_compare_func);
            if (!empty($sub_result)) {
                $result[$key] = $sub_result;
            }
        } else {
            // Compare the current value to the value in the target array
            if (!isset($array2[$key]) || $key_compare_func($key, $key) !== 0) {
                $result[$key] = $value;
            }
        }
    }

    return $result;
}

$array1 = [
    'a' => 'apple',
    'b' => ['ba' => 'banana', 'bb' => 'blueberry'],
    'c' => 'cherry'
];

$array2 = [
    'a' => 'apple',
    'b' => ['ba' => 'banana', 'bb' => 'blackberry'],
    'd' => 'date'
];

$result = recursive_array_diff_uassoc($array1, $array2, 'compare_keys');
print_r($result);

Output:

 Array
(
    [b] => Array
        (
            [bb] => blueberry
        )
    [c] => cherry
)

In this example, we traverse the multidimensional array recursively and perform key-value differences comparisons for each array level. Note that when comparing multidimensional arrays, we process nested arrays separately.

Summarize

The array_diff_uassoc() function itself does not directly support key-value differences comparison of multi-dimensional arrays, but through recursive means, we can compare the key-value differences of each layer in a multi-dimensional array. Through custom callback functions, we can also accurately control the key comparison method, making our comparison more flexible and efficient. Through the above example, we can clearly see how to apply array_diff_uassoc() to handle complex multidimensional arrays.

array_diff_uassoc