PHP中多数组元素按位组合为新数组的高效实现方法

Hey there! Let's solve this array reshaping problem you're dealing with. Your goal is to turn a "horizontal" array (where each key holds an array of values) into a "vertical" array of associative arrays—each containing the corresponding values from each sub-array. And you're right to worry about nested foreach loops hurting performance when dealing with 10+ sub-arrays. Here are two optimized approaches:

1. Clean & Concise: Use array_map with Spread Operator #

This leverages PHP's built-in functions (which are generally optimized for performance) and keeps your code short and readable:

$original = [
    'title' => ["ABC", "DEF", "GHI"],
    'url' => ["abc", "def", "ghi"],
    // Add as many additional sub-arrays as needed here
];

// Extract the keys we'll use for each new associative array
$keys = array_keys($original);

// Use array_map to zip the sub-arrays together
$transformed = array_map(function(...$values) use ($keys) {
    return array_combine($keys, $values);
}, ...array_values($original));

How it works: #

• ...array_values($original) spreads each sub-array from the original into separate arguments for array_map.
• For each index position, array_map passes all corresponding values (e.g., "ABC" and "abc" for index 0) to the anonymous function.
• array_combine pairs the original keys (title, url, etc.) with these values to create each associative array in the result.

This avoids nested loops entirely and is perfect when you want clean code without sacrificing performance.

2. Performance-Focused: Single Loop with Key Iteration #

If you're chasing maximum efficiency (especially with a huge number of sub-arrays or elements), a manual single outer loop is hard to beat. This cuts down on unnecessary iterations compared to nested foreach approaches:

$original = [
    'title' => ["ABC", "DEF", "GHI"],
    'url' => ["abc", "def", "ghi"],
    // More sub-arrays here
];

$keys = array_keys($original);
$itemCount = count(reset($original)); // Assume all sub-arrays have the same length
$transformed = [];

for ($i = 0; $i < $itemCount; $i++) {
    $newItem = [];
    foreach ($keys as $key) {
        $newItem[$key] = $original[$key][$i];
    }
    $transformed[] = $newItem;
}

How it works: #

• We first grab all the keys from the original array and the total number of items (using reset() to get the first sub-array's length—make sure all sub-arrays are the same length!).
• We loop once over each item index, and for each index, build a new associative array by pulling the value from each sub-array at that position.

This approach only runs itemCount + (itemCount * keyCount) operations, which is way more efficient than nested loops that iterate over each sub-array first.

Key Notes: #

• Assumption: All sub-arrays in the original array must have the same length. If they don't, array_map will truncate results to the shortest sub-array, while the manual loop will throw an error if you access an index that doesn't exist in a sub-array. Add validation checks if your input might have variable-length sub-arrays.
• Performance: Both methods are far more efficient than multiple nested foreach loops. array_map is slightly more concise, while the manual loop gives you more control if you need to add custom logic during transformation.

内容的提问来源于stack exchange，提问作者TommyDo