How to use PHP's array_diff() function to implement depth comparison of multidimensional arrays? Does it need to be processed recursively?

M66 2025-05-17

In PHP, array_diff() is a very common function that returns different values in two or more arrays. When comparing multi-dimensional arrays, array_diff() can only compare one-dimensionality of the array. If we need to perform deep comparisons on multi-dimensional arrays, array_diff() itself is not enough to complete this task. In order to achieve depth comparison of multidimensional arrays, we need to use recursion to compare each array element layer by layer.

This article will introduce how to use the array_diff() function in conjunction with recursion to implement deep comparison of multidimensional arrays and explain why recursion is necessary.

Basic usage of array_diff()

First, let’s understand the basic usage of array_diff() . This function returns an array containing all elements that appear in the first array but not in the subsequent array. Its basic syntax is as follows:

 array_diff(array $array1, array ...$arrays): array

For example, the following code shows how to compare two one-dimensional arrays with array_diff() :

 $array1 = [1, 2, 3, 4];
$array2 = [3, 4, 5, 6];

$result = array_diff($array1, $array2);
print_r($result);

Output:

 Array
(
    [0] => 1
    [1] => 2
)

As you can see, array_diff() will return elements that exist in the array $array1 but not in $array2 .

Depth comparison of multidimensional arrays

For comparison of multidimensional arrays, array_diff() cannot be done directly by default because it only compares one-dimensional arrays. When the element of the array itself is an array, array_diff() will directly compare the references of the array instead of recursively comparing.

In order to achieve deep comparison of multidimensional arrays, we need to write a recursive function that compares each element in the array layer by layer. Here is an example of recursive implementation of multi-dimensional array depth comparison:

 function array_diff_recursive($array1, $array2) {
    $result = [];
    
    // Iterate over the first array
    foreach ($array1 as $key => $value) {
        if (is_array($value) && isset($array2[$key]) && is_array($array2[$key])) {
            // If the value is an array and there is also a corresponding array in the second array，Recursive call
            $recursive_diff = array_diff_recursive($value, $array2[$key]);
            if (!empty($recursive_diff)) {
                $result[$key] = $recursive_diff;
            }
        } else {
            // If the value is not an array，Use directly array_diff Make a comparison
            if (!in_array($value, $array2)) {
                $result[$key] = $value;
            }
        }
    }
    
    return $result;
}

$array1 = [
    'a' => 1,
    'b' => [2, 3, 4],
    'c' => 5
];

$array2 = [
    'a' => 1,
    'b' => [2, 3],
    'c' => 5
];

$result = array_diff_recursive($array1, $array2);
print_r($result);

Output:

 Array
(
    [b] => Array
        (
            [2] => 4
        )
)

In this example, array_diff_recursive() will recursively check each item in $array1 and $array2 . If an item is an array and has corresponding arrays in both arrays, it will continue to recursively compare the subarray; if an item is not an array, it will directly use array_diff() for comparison.

Why do you need recursion?

Recursion is the key to implementing deep comparison of multidimensional arrays, because multidimensional arrays may contain subarrays, and these subarrays may also contain more subarrays, and so on. Using recursion ensures that each layer of array is correctly compared. If you do not use recursion, you can only compare the top layer of the array and cannot go deep into each layer.

in conclusion

Although PHP's array_diff() function is very suitable for comparison of one-dimensional arrays, we must use recursion for depth comparison of multidimensional arrays. Through recursion, we can ensure that the elements of each layer of array can be compared one by one. This approach is very effective when dealing with multidimensional arrays, especially when dealing with nested arrays.

If you need to deal with more complex array comparisons, or need to further optimize recursive performance, you may also need to consider some additional optimization measures, but the basic recursive comparison method can meet most needs.

Hopefully the examples in this article help you understand how to use PHP to implement deep comparison of multidimensional arrays.

array_diff