How Can I Efficiently Implement A Recursive Function In PHP To Flatten A Multidimensional Associative Array With Varying Levels Of Nesting, While Preserving The Original Key Structure And Handling Potential Duplicate Keys By Appending A Suffix To The Key, Without Using Any External Libraries Or Packages?

Apr 29, 2025 by ADMIN 306 views

To efficiently flatten a multidimensional associative array in PHP while preserving the key structure and handling duplicate keys by appending a suffix, you can use a recursive approach. This method ensures that each key in the resulting array is unique.

Approach

Recursive Traversal: Use a recursive function to traverse each level of the nested array. For each element, if it's an array, recursively process it, building the key path as you go deeper.
Key Path Construction: Construct the key path by concatenating the current key with the parent keys using a dot (.) as the separator.
Duplicate Handling: Maintain a counter for each key path to track how many times it has been encountered. If a key path is encountered more than once, append a suffix (like _1, _2, etc.) to ensure uniqueness.
Result Accumulation: Collect the key-value pairs in a result array, checking and updating the counters as each key is added.

Solution Code

function flattenArray($array) {
    $result = array();
    $keyCounts = array();
$flattenHelper = function ($array, $prefix = &#39;&#39;) use (&amp;$result, &amp;$keyCounts, &amp;$flattenHelper) {
    foreach ($array as $key =&gt; $value) {
        $currentKey = $prefix ? $prefix . &#39;.&#39; . $key : $key;

        if (is_array($value)) {
            $flattenHelper($value, $currentKey);
        } else {
            if (isset($keyCounts[$currentKey])) {
                $suffix = $keyCounts[$currentKey];
                $newKey = $currentKey . &#39;_&#39; . $suffix;
                $result[$newKey] = $value;
                $keyCounts[$currentKey]++;
            } else {
                $result[$currentKey] = $value;
                $keyCounts[$currentKey] = 1;
            }
        }
    }
};

$flattenHelper($array);

return $result;

}

Explanation

Recursive Helper Function: The flattenHelper function is defined within flattenArray and uses references to the result and keyCounts arrays to accumulate results and track key usage across recursive calls.
Key Path Construction: For each key-value pair, the current key path is built by appending the current key to the prefix (parent keys).
Duplicate Key Handling: Each time a key is about to be added to the result, the function checks if it already exists. If it does, a suffix is appended based on the count of occurrences, ensuring each key is unique.
Efficiency: The function efficiently processes each element exactly once, making it suitable for arrays with varying levels of nesting.

This approach ensures that the multidimensional array is flattened into a single-level associative array with unique keys, preserving the original structure and handling duplicates appropriately.