PHP多维数组扁平化：深度解析与高效实践145

在PHP编程中，数组是我们处理数据最核心的结构之一。随着业务逻辑的复杂化，我们经常会遇到多维数组，它们以嵌套的形式存储着丰富的关联数据。然而，在某些特定的场景下，如数据导入导出、API接口数据传输、全文搜索索引构建，或者仅仅是为了简化数据处理逻辑，我们需要将这些层层嵌套的多维数组“扁平化”为一维数组。这个过程，我们称之为“数组去维”或“数组扁平化”。

作为一名专业的程序员，熟练掌握多维数组的扁平化技术，并理解不同方法的优劣和适用场景，是提升代码质量和运行效率的关键。本文将深入探讨PHP中实现数组扁平化的各种策略，包括递归、迭代、内置函数以及性能考量和最佳实践，旨在为读者提供一个全面且实用的指南。

理解多维数组与扁平化的必要性

首先，让我们明确什么是多维数组。简单来说，一个多维数组就是数组中包含着一个或多个子数组。这些子数组又可以包含其他子数组，形成任意深度的嵌套结构。例如：
$multiDimensionalArray = [
'user' => [
'id' => 123,
'name' => 'Alice',
'details' => [
'email' => 'alice@',
'phone' => ['+1-555-1234', '+1-555-5678'],
'address' => [
'street' => '123 Main St',
'city' => 'Anytown',
'zip' => '10001'
]
]
],
'products' => [
['id' => 1, 'name' => 'Laptop'],
['id' => 2, 'name' => 'Mouse']
],
'status' => 'active'
];

在上述例子中，`$multiDimensionalArray`是一个三维数组，`phone`字段甚至是一个包含多个元素的数组。如果我们需要将所有叶子节点的值（如123, 'Alice', 'alice@', '+1-555-1234', 'Laptop'等）提取出来，放入一个简单的一维数组中，这就是扁平化的目标。

扁平化的必要性体现在多个方面：
数据传输与存储：许多数据格式（如CSV、简单的JSON数组）或数据库存储要求数据扁平化。
搜索与索引：构建全文搜索索引时，可能需要将所有文本内容提取到一个平面列表中进行处理。
统一数据处理：有时为了对所有数据项进行统一操作（如过滤、映射），扁平化可以简化逻辑。
API响应：某些API设计可能偏好返回扁平化的数据结构。

PHP中实现数组扁平化的主要方法

PHP提供了多种方法来实现数组扁平化，每种方法都有其特点和适用场景。我们将详细介绍递归、迭代和内置函数这三种主要策略。

1. 递归方法 (Recursive Approach)

递归是处理嵌套数据结构最直观、最优雅的方法之一。其核心思想是函数在处理数组时，如果遇到子数组，就再次调用自身来处理这个子数组，直到所有元素都被访问。这种方法特别适合处理深度不确定的多维数组。
/
* 递归扁平化数组
* 将多维数组的所有叶子节点值收集到一个一维数组中。
*
* @param array $array 待扁平化的多维数组
* @return array 扁平化后的一维数组
*/
function flattenArrayRecursive(array $array): array
{
$result = [];
foreach ($array as $item) {
if (is_array($item)) {
// 如果是数组，则递归调用自身，并将结果合并到当前结果中
$result = array_merge($result, flattenArrayRecursive($item));
} else {
// 如果不是数组，直接添加到结果中
$result[] = $item;
}
}
return $result;
}
// 示例使用
$flattened = flattenArrayRecursive($multiDimensionalArray);
print_r($flattened);
/* 输出示例:
Array
(
[0] => 123
[1] => Alice
[2] => alice@
[3] => +1-555-1234
[4] => +1-555-5678
[5] => 123 Main St
[6] => Anytown
[7] => 10001
[8] => 1
[9] => Laptop
[10] => 2
[11] => Mouse
[12] => active
)
*/

优缺点分析：

优点：代码简洁、易于理解，能够优雅地处理任意深度的嵌套结构。
缺点：

栈溢出风险：当数组嵌套层级非常深时（例如上千层），可能会导致PHP函数调用栈溢出（Stack Overflow）。尽管在实际应用中这种情况不常见，但对于极端数据结构需要注意。
性能开销：`array_merge` 在循环中频繁调用，每次调用都会创建一个新数组并进行内存拷贝，这可能带来一定的性能开销，尤其对于大型数组。

2. 迭代方法 (Iterative Approach - 基于栈/队列)

迭代方法通过维护一个显式的数据结构（如栈或队列）来模拟递归过程，从而避免了函数调用栈的限制。这对于处理极其深层嵌套的数组是一个更健壮的选择。
/
* 迭代扁平化数组 (使用栈模拟深度优先遍历)
* 避免递归的栈溢出风险。
*
* @param array $array 待扁平化的多维数组
* @return array 扁平化后的一维数组
*/
function flattenArrayIterative(array $array): array
{
$result = [];
$stack = [$array]; // 初始化一个栈，将原始数组作为第一个要处理的元素
while (!empty($stack)) {
$current = array_pop($stack); // 从栈顶取出一个元素
// PHP 8+ 可以使用 array_is_list() 来判断是否为列表数组，以便优化处理
// if (is_array($current) && array_is_list($current)) {
if (is_array($current)) { // 兼容所有PHP版本
// 倒序遍历数组元素，这样子数组会先被压入栈，实现深度优先
foreach (array_reverse($current) as $item) {
if (is_array($item)) {
array_push($stack, $item); // 如果是数组，压入栈中待处理
} else {
// 如果不是数组，直接添加到结果数组中 (注意这里是倒序添加，结果顺序会与递归不同)
// 如果需要保持原始顺序，需要调整遍历和添加的逻辑，例如使用队列或更复杂的栈处理
$result[] = $item;
}
}
} else {
// 如果 $current 本身就是非数组叶子节点（这种情况通常不会发生，因为我们压入栈的都是数组）
// 实际上，这里的逻辑主要处理的是 $current 是数组的情况。
// 考虑到扁平化是提取叶子节点，这里应该直接添加到结果中，
// 但由于我们总是将数组压入栈，这个else分支通常不会被命中，除非初始数组就不是数组。
// 为了安全起见，可以确保 $current 总是数组。
$result[] = $current; // 这行代码通常不会执行到，因为我们pop出来的是数组。
}
}
// 注意：由于栈的LIFO特性和我们pop/push的顺序，直接这样实现的迭代扁平化可能会导致结果顺序与递归不同。
// 如果需要与递归方法相同的顺序，可能需要将最终结果反转，或者调整遍历和添加的逻辑。
// 例如，将叶子节点推入另一个栈，最后再pop出来。或者使用队列 (FIFO) 模拟广度优先遍历。
// 考虑顺序问题，如果希望与递归方法结果顺序一致，可以先将叶子节点收集到一个临时栈中，最后再反转。
// 更简单的迭代实现，通常会直接将叶子节点添加到结果中，接受顺序差异。
return array_reverse($result); // 反转以尝试匹配递归的深度优先顺序
}
// 示例使用
$flattenedIterative = flattenArrayIterative($multiDimensionalArray);
print_r($flattenedIterative);
/* 输出示例 (可能与递归顺序略有不同，取决于具体实现和反转)：
Array
(
[0] => 123
[1] => Alice
[2] => alice@
[3] => +1-555-1234
[4] => +1-555-5678
[5] => 123 Main St
[6] => Anytown
[7] => 10001
[8] => 1
[9] => Laptop
[10] => 2
[11] => Mouse
[12] => active
)
*/

关于迭代方法顺序的补充说明：
上述迭代方法采用栈（LIFO，后进先出）模拟深度优先遍历，并对子数组元素进行倒序压栈，以便在后续处理时能按“逻辑”顺序弹出。然而，将非数组叶子节点直接添加到`$result`数组中，由于栈的特性，会导致叶子节点的收集顺序与递归方法（通常是深度优先，从左到右）不一致。如果需要严格保持与递归方法相同的顺序，通常需要更复杂的迭代逻辑，例如：将所有叶子节点收集到一个临时栈中，最后再通过 `array_reverse` 来获得正确顺序，或者使用一个队列（FIFO，先进先出）来模拟广度优先遍历。
// 迭代方法（广度优先遍历 - 通常更容易保持类似“从左到右”的顺序）
function flattenArrayIterativeQueue(array $array): array
{
$result = [];
$queue = [$array]; // 使用队列，先进先出
while (!empty($queue)) {
$current = array_shift($queue); // 从队列头部取出一个元素
foreach ($current as $item) {
if (is_array($item)) {
array_push($queue, $item); // 如果是数组，压入队列尾部待处理
} else {
$result[] = $item; // 如果不是数组，直接添加到结果数组中
}
}
}
return $result;
}
// 示例使用
$flattenedIterativeQueue = flattenArrayIterativeQueue($multiDimensionalArray);
print_r($flattenedIterativeQueue);
// 广度优先遍历的结果顺序通常会先展示浅层节点，再展示深层节点。

优缺点分析：

优点：

无栈溢出风险：避免了PHP函数调用栈的限制，可以处理任意深度的数组嵌套。
内存控制：相对于频繁的`array_merge`，通过控制栈或队列的入队/出队操作，可以更精细地管理内存。


缺点：

代码相对复杂：相对于递归，迭代的代码逻辑理解起来可能稍显复杂。
顺序问题：如果对输出元素的顺序有严格要求，需要仔细设计迭代逻辑（如使用栈进行深度优先遍历并适当反转，或使用队列进行广度优先遍历）。

3. PHP内置函数 `array_walk_recursive()`

PHP提供了一个专门用于递归遍历多维数组的内置函数 `array_walk_recursive()`。这个函数会对数组中的每个叶子节点执行一个回调函数，这使得它非常适合用于扁平化操作。
/
* 使用 array_walk_recursive 扁平化数组
*
* @param array $array 待扁平化的多维数组
* @return array 扁平化后的一维数组
*/
function flattenArrayWithWalkRecursive(array $array): array
{
$result = [];
array_walk_recursive($array, function ($item) use (&$result) {
$result[] = $item;
});
return $result;
}
// 示例使用
$flattenedWalk = flattenArrayWithWalkRecursive($multiDimensionalArray);
print_r($flattenedWalk);
/* 输出示例 (顺序与递归方法一致):
Array
(
[0] => 123
[1] => Alice
[2] => alice@
[3] => +1-555-1234
[4] => +1-555-5678
[5] => 123 Main St
[6] => Anytown
[7] => 10001
[8] => 1
[9] => Laptop
[10] => 2
[11] => Mouse
[12] => active
)
*/

优缺点分析：

优点：

简洁高效：代码非常简洁，利用PHP底层实现，通常性能优异，并且无栈溢出风险。
内置支持：作为PHP内置函数，其稳定性和兼容性良好。
顺序保持：通常能够保持与深度优先遍历相似的元素顺序。


缺点：

灵活性有限：回调函数只能访问叶子节点的值，无法直接访问其父级键或深度信息。如果扁平化过程中需要对键进行特殊处理（例如，将多维路径合并成一个扁平键），则此方法不适用或需要额外逻辑。

4. 使用 `array_reduce()` (结合递归)

`array_reduce()` 函数可以将数组归约（reduce）为单一值。虽然它本身不是直接用于扁平化的，但可以与递归结合使用，以一种函数式编程的风格实现扁平化。
/
* 使用 array_reduce 和递归扁平化数组
*
* @param array $array 待扁平化的多维数组
* @return array 扁平化后的一维数组
*/
function flattenArrayWithReduce(array $array): array
{
return array_reduce($array, function (array $carry, $item) {
if (is_array($item)) {
// 如果是数组，则递归调用自身，并将结果合并到累积器中
return array_merge($carry, flattenArrayWithReduce($item));
} else {
// 如果不是数组，直接添加到累积器中
$carry[] = $item;
return $carry;
}
}, []); // 初始累积器为空数组
}
// 示例使用
$flattenedReduce = flattenArrayWithReduce($multiDimensionalArray);
print_r($flattenedReduce);
/* 输出示例 (顺序与递归方法一致):
Array
(
[0] => 123
[1] => Alice
[2] => alice@
[3] => +1-555-1234
[4] => +1-555-5678
[5] => 123 Main St
[6] => Anytown
[7] => 10001
[8] => 1
[9] => Laptop
[10] => 2
[11] => Mouse
[12] => active
)
*/

优缺点分析：

优点：代码风格更偏向函数式，简洁明了，特别是对于熟悉`reduce`概念的开发者。
缺点：本质上仍然是递归，因此存在同样的栈溢出风险。并且，`array_merge`的性能开销也依然存在。在性能上，通常不如直接的递归方法（因为多了`array_reduce`本身的函数调用开销），但语义上可能更清晰。

键的保留与处理：扁平化的进阶考虑

上述所有扁平化方法都只关注了提取数组的“值”（value），并将其放入一个新的一维数组中，新的数组会重新索引（从0开始）。但在某些场景下，我们可能需要保留或转换原始数组中的“键”（key）。

例如，我们可能希望将多维数组的路径作为新数组的键，例如将 `['user']['details']['email']` 变为 `user_details_email` 作为键。这已经超出了简单的“去维”范畴，更像是一种“键值重映射与扁平化”，需要更复杂的递归逻辑来构建新的键。
/
* 递归扁平化数组，并使用路径作为新数组的键
*
* @param array $array 待扁平化的多维数组
* @param string $prefix 当前路径前缀
* @param string $separator 路径分隔符
* @return array 扁平化后的一维关联数组
*/
function flattenArrayWithKeys(array $array, string $prefix = '', string $separator = '_'): array
{
$result = [];
foreach ($array as $key => $value) {
$newKey = $prefix ? $prefix . $separator . $key : $key;
if (is_array($value)) {
// 如果是数组，递归调用自身，并将结果合并
$result = array_merge($result, flattenArrayWithKeys($value, $newKey, $separator));
} else {
// 如果不是数组，直接添加到结果中，使用新的路径键
$result[$newKey] = $value;
}
}
return $result;
}
// 示例使用
$flattenedWithKeys = flattenArrayWithKeys($multiDimensionalArray, '', '.'); // 使用点作为分隔符
print_r($flattenedWithKeys);
/* 输出示例:
Array
(
[] => 123
[] => Alice
[] => alice@
[.0] => +1-555-1234
[.1] => +1-555-5678
[] => 123 Main St
[] => Anytown
[] => 10001
[] => 1
[] => Laptop
[] => 2
[] => Mouse
[status] => active
)
*/

这种带键的扁平化方法更加强大，但需要开发者根据具体需求来设计键的生成逻辑。

性能考量与最佳实践

在选择扁平化方法时，性能是一个不可忽视的因素。对于小型或中型数组，不同方法的性能差异可能不明显。但对于包含大量元素或深度极深的数组，性能瓶颈可能会凸显。
`array_merge` 的开销：在循环中频繁调用 `array_merge` 会导致性能下降，因为它每次都会创建新数组并进行内存拷贝。如果可能，尽量减少 `array_merge` 的调用次数，或者在收集所有元素后再进行一次合并。
递归深度：如果数组嵌套深度可能非常大，应优先考虑迭代方法或 `array_walk_recursive`，以避免栈溢出。
`array_walk_recursive` 通常是首选：对于只提取叶子节点值的情况，`array_walk_recursive` 通常是效率最高且代码最简洁的选择，因为它是由C语言实现的，经过高度优化。
提前预判：如果已知数组的深度或结构，有时可以设计更具针对性的迭代逻辑。
避免不必要的扁平化：在进行扁平化之前，先思考是否真的需要将数组扁平化。有时通过多维数组的遍历和访问也能解决问题，且能保留数据的原始结构和语义。
内存使用：处理非常大的数组时，关注内存使用。迭代方法通过逐步处理元素，可以比一次性构建大量中间数组的递归方法更节省内存。

PHP多维数组的扁平化是一个常见的需求，解决之道多种多样。从直观优雅的递归，到健壮高效的迭代，再到PHP内置的 `array_walk_recursive`，每种方法都有其独特的适用场景和优缺点。
对于大多数需要简单提取叶子节点值的场景，`array_walk_recursive()` 是最推荐的方法，因为它既简洁又高效。
如果数组的嵌套深度可能非常大，并且担心栈溢出，迭代方法（基于栈或队列）是更安全、更健壮的选择。
如果偏爱函数式编程风格，或者数组深度可控，结合`array_reduce()`的递归方法也是一种可行方案。
当需要将多维数组的路径信息融入到扁平化后的键中时，则需要编写自定义的递归函数来实现更复杂的键值映射。

作为专业的程序员，我们不仅要知其然，更要知其所以然。理解这些方法的内部机制、性能特点和潜在风险，才能在实际开发中做出最明智、最符合项目需求的选择，编写出高质量、高性能的PHP代码。

2026-02-25

---

上一篇：PHP与中文：告别乱码困扰，全面拥抱UTF-8编码最佳实践

下一篇：PHP字符串处理实战：从定位到高级模式匹配的全面指南