The standard array_diff() cannot handle nested arrays because it only performs shallow comparisons and does not recurse; 2. The solution is to implement a recursive diff function, which traverses and compares each key value through strict comparisons. If the value is an array, it will call itself recursively; 3. The function returns a structured array containing only the differences, retaining the original nested structure; 4. The example shows that the function can correctly identify deep changes such as configuration, settings, and labels; 5. Optional enhancements include bidirectional comparisons, ignoring specific keys, supporting objects and string standardization; 6. Notes include performance decreasing with the increase in the depth of the array, not processing circular references, and preprocessing objects. This method effectively makes up for the shortcomings of PHP built-in functions in complex array comparisons and provides clear and accurate differences.

Comparing multidimensional arrays in PHP—especially when dealing with nested structures—can be tricky. Built-in functions like array_diff() fall short because they don't handle recursion or deep comparisons. To properly detect differences between complex arrays, you need a custom recursive diff algorithm.

Here's how to implement a robust recursive diff function in PHP that works heavily with nested arrays.

Why Standard array_diff() Fails with Nested Arrays

PHP's array_diff() only compares values at the first level and uses loose comparison. It cannot:

• Traverse nested arrays
• Compare associated keys recursively
• Handle mixed types or deep structures

For example:

 $a = ['config' => ['debug' => true, 'mode' => 'dev']];
$b = ['config' => ['debug' => false, 'mode' => 'prod']];

var_dump(array_diff($a, $b)); // Returns empty! No useful output.

This makes array_diff() nearly useless for configuration diffs, API responses, or data snapshots.

Building a Recursive Diff Function

The goal is to return a structured array showing only the differences, preserving the original keys and nesting.

 function recursiveDiff($array1, $array2) {
    $difference = [];

    foreach ($array1 as $key => $value) {
        if (!array_key_exists($key, $array2)) {
            $difference[$key] = $value;
        } elseif (is_array($value)) {
            if (!is_array($array2[$key])) {
                $difference[$key] = $value; // Type mismatch
            } else {
                $subDiff = recursiveDiff($value, $array2[$key]);
                if (!empty($subDiff)) {
                    $difference[$key] = $subDiff;
                }
            }
        } elseif ($value !== $array2[$key]) {
            $difference[$key] = $value;
        }
    }

    // Check for keys present in $array2 but not in $array1 (optional: symmetric diff)
    foreach ($array2 as $key => $value) {
        if (!array_key_exists($key, $array1)) {
            $difference[$key] = null; // Or $value, depending on use case
        }
    }

    return $difference;
}

How It Works

The function does the following:

• Loops through the first array
• Checks if a key exists in the second array
• If the value is an array, calls itself recursively
• Only include values in the result if there's an actual difference
• Optionally detects keys missing from the first array

Key behaviors:

• Uses strict comparison ( !== ) to catch type and value differences
• Preserves structure: differences mirror the original nesting
• Handles mixed data types safely

Example Usage

 $old = [
    'user' => 'john',
    'settings' => [
        'theme' => 'dark',
        'notifications' => [
            'email' => true,
            'sms' => false
        ]
    ],
    'tags' => ['a', 'b']
];

$new = [
    'user' => 'john',
    'settings' => [
        'theme' => 'light',
        'notifications' => [
            'email' => false,
            'sms' => false
        ]
    ],
    'tags' => ['a', 'c'],
    'status' => 'active'
];

$dif = recursiveDiff($old, $new);
print_r($difference);

Output:

 Array
(
    [settings] => Array
        (
            [theme] => light
            [notifications] => Array
                (
                    [email] => 
                )
        )
    [tags] => Array
        (
            [1] => c
        )
    [status] => active
)

Note: The tags difference appears because array_diff on indexed arrays compares values by position. Since both arrays have 2 elements but different second values, it shows up.

If you want to compare lists more intelligently (eg, set-style), consider normalizing indexed arrays first or using a separate diff strategy for sequences.

Optional Enhancements

You might want to extend the function based on your needs:

• Bidirectional diff : Show what changed in both directions
• Return both old and new values :

   $difference[$key] = ['old' => $value, 'new' => $array2[$key]];

• Ignore certain keys (eg, timestamps)
• Support objects by converting to arrays or using get_object_vars()
• Normalize case or whitespace for strings

---

Limitations and Notes

• Does not handle object comparison unless converted
• Indexed arrays are compared by key (position), so reordering causes diffs
• Circular references will cause infinite loops (add detection if needed)
• Performance degrades on very large or deeply nested arrays

For production systems, consider caching or limiting depth.

---

Basically, this recursive diff gives you a clean, readable output of what actually changed in complex PHP arrays. It's not hard to build, but gets the job done where built-in tools fail.

The above is the detailed content of Implementing a Recursive Diff Algorithm for PHP Multidimensional Arrays. For more information, please follow other related articles on the PHP Chinese website!