How to flatten a multidimensional array? 1. Use recursive functions to manually traverse the array. If the elements are still arrays, continue to go deeper until all values ??are collected; 2. Use PHP's built-in RecursiveIteratorIterator and RecursiveArrayIterator to achieve automatic expansion; Note: Both methods discard the original key names by default. If you need to retain the logic, you should modify it and deal with the overwrite of duplicate keys.

Sometimes when we are processing PHP arrays, we will encounter a multi-dimensional array and want to "flat" it into a one-dimensional array. For example, if you take a bunch of data from the database, the structure is nested deeply, but you only want to get all the values ??inside, and you need to flatten it.

It is actually not difficult to implement this. The key is to recursively traverse each element in the array and "pour out" them layer by layer.

Manual flattening using recursive functions

This is the most common and flexible method. You can write a recursive function that iterates through each element of the array. If an element is still an array, continue to process it in depth until you find the "leaf node" and then collect it.

 function flattenArray($array) {
    $result = [];

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

    return $result;
}

For example:

 $input = [1, [2, [3, 4], 5]];
$output = flattenArray($input);
// The result is: [1, 2, 3, 4, 5]

The advantage of this method is that you have complete control over the logic. For example, if you want to filter out certain types of data or do additional processing, you can add judgments in it.

Using PHP built-in class RecursiveIteratorIterator

If you don't want to write recursive logic yourself, PHP provides a built-in way: use RecursiveIteratorIterator and RecursiveArrayIterator to automatically expand multidimensional arrays.

 function flattenArrayUsingIterator($array) {
    $iterator = new \RecursiveIteratorIterator(
        new \RecursiveArrayIterator($array)
    );

    $result = [];
    foreach ($iterator as $value) {
        $result[] = $value;
    }

    return $result;
}

The effect is the same as above, but it is implemented in a more object-oriented way. This writing may be more popular in projects with high code style requirements and is not prone to errors.

Note: Associative array and flat key names issues

Both methods above will discard the original key name and return a one-dimensional array of numeric indexes. If you want to keep the original key, you need to change the logic a little.

For example, in the recursive version, it can be changed to this:

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

    return $result;
}

However, be aware that if there are the same keys in multiple levels, the subsequent values ??will override the previous one. Therefore, when processing associative arrays, you need to decide based on the business whether to merge, rename or ignore duplicate keys.

Basically that's it. Using recursive functions is the most direct way, while using iterators is safer and suitable for situations where nesting depth is not determined. Which method to choose depends on your specific needs.

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