There are three common ways to flatten multidimensional arrays. 1. Use recursive traversal to process arrays of any depth, and use is_array() to determine whether to continue in-depth; 2. It is safer to simulate the recursive process in iterative way, suitable for large data volumes, and use the stack structure to save the elements to be processed; 3. If the array is two-dimensional and the child elements are arrays, it can be implemented concisely by array_merge combined with the expansion operator (...), but it requires support from PHP 7.4; in addition, if you need to preserve key values, you can use the merge array through modification logic.

Sometimes the data you get from a database or API is a nested array, but you need to turn it into a one-dimensional array to process. At this time, we need to "flatten" this multi-dimensional array. PHP does not have built-in functions to do this directly, but we can implement it ourselves.

The following introduces several common practices that are suitable for array structures of different scenarios and complexities.

Use recursive traversal to process arrays of arbitrary depths

If you are not sure how many layers are nested in the array, the safest way is to use recursion to expand it layer by layer.

 function flattenArray($array) {
    $result = [];
    foreach ($array as $value) {
        if (is_array($value)) {
            $result = array_merge($result, flattenArray($value));
        } else {
            $result[] = $value;
        }
    }
    return $result;
}

• This method is suitable for arrays with no fixed levels.
• Use is_array() to determine whether to go deeper.
• Note: If the data contains non-array elements (such as objects), additional judgment processing is required.

Use iteration instead of recursion to avoid stack overflow

If you are worried that recursion may cause stack overflow (such as arrays being particularly deep), you can simulate the recursion process iteratively :

 function flattenArrayIterative($array) {
    $result = [];
    $stack = array_values($array); // Make sure the index is continuous while (!empty($stack)) {
        $current = array_pop($stack);
        if (is_array($current)) {
            foreach ($current as $item) {
                $stack[] = $item;
            }
        } else {
            $result[] = $current;
        }
    }

    return array_reverse($result);
}

• This writing method is safer, especially when dealing with big data.
• The principle is to use a "stack" to save the elements to be processed.
• The array is finally reversed to keep the order consistent.

If it is just a two-dimensional array, it can be merged simply and roughly

If you are sure that the array has only two layers, you can use array_merge to add the expansion operator:

 $array = [[1, 2], [3, 4], [5]];
$result = array_merge(...$array);
// Results: [1, 2, 3, 4, 5]

• This is the simplest way.
• But it only applies to cases where all child elements are arrays.
• PHP 7.4 supports the expansion operator (...) for arrays.

Tips: Keep key values ??when processing associative arrays?

All the above examples ignore the key names. If you want to keep the original key value, you can change the logic a little:

 function flattenWithKeys($array) {
    $result = [];
    foreach ($array as $key => $value) {
        if (is_array($value)) {
            $result = $result flattenWithKeys($value);
        } else {
            $result[$key] = $value;
        }
    }
    return $result;
}

• use Merge the array instead of array_merge so that the numeric keys are not reset.
• Suitable for scenarios where the original key name needs to be retained.

Basically these are the methods. You can choose the most suitable one based on the actual array structure. Common solutions such as recursion and iteration are very practical when writing tool functions.

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