array_walk_recursive() recursively processes each non-array element of a multidimensional array. It will automatically penetrate deep into the nested structure, apply a callback function to each leaf node value, ignoring the empty array and the subarray itself. For example, it can be used to directly modify the values ??in the original array, such as converting all numbers into floating point types. However, it is not suitable for scenarios such as operating keys, returning new arrays, or processing objects. At this time, custom recursive functions should be used to achieve more granular control. When debugging, you need to pay attention to reference passing, type checking, and empty array skipping.

If you're working with multidimensional arrays in PHP and want to apply a function to every element — no matter how deep it is nested — array_walk_recursive() is the right tool. It automatically dives into nested arrays and applies your callback to each leaf value, skipping any sub-arrays themselves.

What does array_walk_recursive() actually do?

This function walks through an array recursively, meaning it goes into each level of nesting. It passes each leaf node (the actual values, not the arrays) to your custom function. The key point: it ignores empty arrays and only touches elements that aren't themselves arrays.

Example:

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

array_walk_recursive($multi, function(&$value) {
    $value *= 2;
});

After this runs, all numeric values ??will be doubled, even those inside deeper levels like the 4 and 5 inside the nested array.

How to modify values ??in place

One common use is modifying the original array directly. To do that, make sure you're using a reference ( &$value ) in your callback.

Here's a basic pattern:

• Use array_walk_recursive() with a callback that accepts &$value
• Modify $value directly inside the function

Example:

 $data = [
    ['price' => '10.99', 'qty' => '3'],
    ['price' => '5.49', 'qty' => '10'],
];

array_walk_recursive($data, function(&$value) {
    if (is_numeric($value)) {
        $value = (float)$value;
    }
});

Now all string numbers are converted to floats without looping manually through each level.

When to avoid array_walk_recursive()

There are some cases where this function isn't the best fit:

• You need to manipulate keys or arrays themselves (not just leaf values)
• You want to return a new transformed array instead of modifying in place
• Your structure contains objects or special data types

In these cases, writing a custom recursive function gives you more control.

Custom example:

 function deepTransform(&$array, $callback) {
    foreach ($array as &$value) {
        if (is_array($value)) {
            deepTransform($value, $callback);
        } else {
            $value = $callback($value);
        }
    }
}

deepTransform($data, function($val) {
    return strtoupper($val);
});

This way, you can return a modified value and keep better control over what gets changed.

Keep in mind when debugging

Sometimes things don't change as expected. A few gotchas:

• Make sure you're using &$value in the callback if you want to modify the original
• If your array has non-scalar values ??(like objects), the function will still pass them unless you add type checks
• Emty arrays are skipped silently — so if your data might contain placeholders, handle them before applying the function

You can test by dumping inside the callback:

 array_walk_recursive($arr, function($v, $k) {
    var_dump($k, $v);
});

That helps confirm whether the function is reaching all intended values.

It's a solid one-liner for deeply transforming flat values ??in nested arrays. Just remember it works in place and skips sub-arrays, which makes it fast but limited compared to writing your own loop.

The above is the detailed content of how to use array_walk_recursive on a multidimensional php array. For more information, please follow other related articles on the PHP Chinese website!