理解问题：复杂嵌套数组的扁平化挑战
在javascript开发中，我们经常会遇到需要处理多层嵌套数组的场景。然而，有时我们需要的不是完全扁平化（例如，将所有元素提取到单一的一维数组中），而是将数组扁平化到特定的层次结构，例如，一个“干净”的二维数组，其中每个元素本身都是一个一维数组，但不再包含更深层的数组。
考虑以下初始数组结构：
const twoDimensionalArray = [ [1, 2, 3, 4], [[5, 6], [9, 10]], // 这是一个包含两个子数组的数组 [5, 6, 7] ];
我们期望的输出是一个二维数组，其中[[5, 6], [9, 10]]被展开为[5, 6]和[9, 10]两个独立的元素，最终结果应为：
// 期望输出: [[1, 2, 3, 4], [5, 6], [9, 10], [5, 6, 7]]
初步尝试：flatMap的局限性
Array.prototype.flatMap()方法是ES2019引入的，它首先使用映射函数对每个元素进行映射，然后将结果扁平化一层。对于简单的扁平化场景，它非常方便。然而，对于我们当前的特定需求，flatMap可能会导致过度扁平化或无法达到精确的控制。
让我们看一个使用flatMap的尝试：
立即学习“Java免费学习笔记（深入）”；
function convertArrInitialAttempt() {
const separateNestedArrays = function (arr) {
return arr.flatMap((element) => {
if (Array.isArray(element)) {
// 如果元素是数组，我们返回它。但如果它是[[5,6], [9,10]]，
// flatMap会将其扁平化一层，导致[5,6,9,10]或更复杂的结果。
return element;
} else {
return [element];
}
});
};
const twoDimensionalArray = [
[1, 2, 3, 4],
[[5, 6], [9, 10]],
[5, 6, 7]
];
const modifiedArray = separateNestedArrays(twoDimensionalArray);
console.log("flatMap尝试的输出:", modifiedArray);
// 实际输出: [ 1, 2, 3, 4, [ 5, 6 ], [ 9, 10 ], 5, 6, 7 ]
// 这个输出仍然不符合预期，它将[[5,6],[9,10]]视为单个元素，并将其子数组保留。
// 更糟糕的是，如果flatMap内部逻辑不当，可能会将其展开为 [1, 2, 3, 4, 5, 6, 9, 10, 5, 6, 7]
// 这里的`return element`在`flatMap`的上下文中，当`element`是`[[5,6],[9,10]]`时，
// `flatMap`会将其扁平化一层，结果是`[5,6,9,10]`，而不是`[5,6]`和`[9,10]`作为独立元素。
// 而我们提供的示例代码的输出 `[ 1, 2, 3, 4, [ 5, 6 ], [ 9, 10 ], 5, 6, 7 ]`
// 实际上是由于`flatMap`的内部处理机制和`Array.isArray(element)`的判断导致的，
// 它没有像我们期望的那样将`[[5,6],[9,10]]`中的`[5,6]`和`[9,10]`单独提取出来。
};
convertArrInitialAttempt();从上述尝试可以看出，flatMap在处理像[[5, 6], [9, 10]]这种“数组的数组”时，如果仅仅返回element，它会将其视为一个整体，或者根据其扁平化规则，将其内部的元素（即[5, 6]和[9, 10]）直接提升到外层，导致扁平化过度或不符合预期。我们需要的不是将[5,6]和[9,10]合并成[5,6,9,10]，而是将它们作为独立的二维数组元素。
解决方案：利用 Array.reduce 实现精确控制
为了实现这种精确的扁平化，Array.prototype.reduce()方法提供了更强大的控制能力。reduce允许我们遍历数组，并根据自定义逻辑构建一个新的累加器（accumulator）。
核心思路是：
- 初始化一个空数组作为累加器。
- 遍历原始数组的每个元素。
- 对于每个元素，判断它是否是一个“数组的数组”（即，它的第一个元素是否也是一个数组）。
- 如果是，说明它需要被进一步展开，将其内部的每个子数组逐一添加到累加器中。
- 如果不是，说明它已经是一个符合我们要求的“一维数组”，直接将其添加到累加器中。
下面是使用Array.reduce实现此功能的代码：
function convertArr() {
const separateNestedArrays = (arr) => arr.reduce((accumulator, currentElement) => {
// 判断当前元素（currentElement）是否是一个包含数组的数组
// 例如，当currentElement是 [[5, 6], [9, 10]] 时，currentElement[0] 是 [5, 6]，
// Array.isArray([5, 6]) 为 true。
if (Array.isArray(currentElement[0])) {
// 如果是，遍历currentElement内部的每个子数组，并逐一推入累加器
currentElement.forEach(subArray => accumulator.push(subArray));
} else {
// 如果不是（例如，[1, 2, 3, 4]），则直接将当前元素推入累加器
accumulator.push(currentElement);
}
return accumulator; // 返回更新后的累加器
}, []); // 初始累加器为空数组
const twoDimensionalArray = [
[1, 2, 3, 4],
[
[5, 6],
[9, 10]
],
[5, 6, 7]
];
const modifiedArray = separateNestedArrays(twoDimensionalArray);
console.log("reduce方法的输出:", modifiedArray);
// 期望输出: [[1, 2, 3, 4], [5, 6], [9, 10], [5, 6, 7]]
// 实际输出: [[1, 2, 3, 4], [5, 6], [9, 10], [5, 6, 7]]
};
convertArr();代码解析与注意事项
-
arr.reduce((accumulator, currentElement) => { ... }, []):
- reduce方法接收一个回调函数和一个初始值（[]，一个空数组）。
- accumulator (b在原始答案中) 是累加器，它在每次迭代中保存着之前处理的结果。
- currentElement (a在原始答案中) 是当前正在处理的数组元素。
-
if (Array.isArray(currentElement[0])):
- 这是判断逻辑的关键。它检查当前元素的第一个子元素是否为数组。
- 如果 currentElement 是 [1, 2, 3, 4]，那么 currentElement[0] 是 1，Array.isArray(1) 为 false。
- 如果 currentElement 是 [[5, 6], [9, 10]]，那么 currentElement[0] 是 [5, 6]，Array.isArray([5, 6]) 为 true。
- 这种判断方式巧妙地识别了需要进一步展开的“数组的数组”结构。
-
currentElement.forEach(subArray => accumulator.push(subArray)):
- 当 currentElement 是 [[5, 6], [9, 10]] 时，此循环会分别将 [5, 6] 和 [9, 10] 推入 accumulator，从而实现精确的扁平化。
-
else { accumulator.push(currentElement); }:
- 当 currentElement 是 [1, 2, 3, 4] 或 [5, 6, 7] 时，它直接被推入 accumulator，保持其原始的一维数组结构。
-
return accumulator;:
- 每次迭代结束时，必须返回 accumulator，以便它在下一次迭代中作为新的 accumulator 使用。
总结
当需要对嵌套数组进行特定层次的扁平化，而不是简单地将所有元素提取到一维数组时，Array.reduce提供了一个强大且灵活的解决方案。通过结合条件判断，我们可以精确控制哪些数组需要进一步展开，哪些可以直接添加，从而生成符合特定结构要求的“干净”二维数组。相比于flatMap在某些场景下的自动扁平化行为，reduce提供了更细粒度的控制，使其成为处理复杂数组转换任务的理想选择。
