迭代式按指定深度扁平化数组（栈/数组拼接）问题求助

嘿，这个深度扁平化的问题我之前也踩过坑！你的核心问题在于没有给每个待处理的元素绑定对应的剩余扁平化深度，而是用了全局的d变量，导致处理完一个嵌套数组后，深度无法正确回溯到之前的层级，影响后续元素的处理。

问题分析 #

你原代码里的d = depth会在每次遍历新元素时重置深度，比如处理[[3], 'ddd', [4,[5]]]这个子数组时，你把d又设回了初始的2，导致原本只需要扁平化到深度2的元素被过度处理，同时无法正确保留[5]这个需要停在当前深度的结构。

方案1：标准栈实现（推荐） #

栈是处理这类嵌套结构的经典方式，关键是让栈里的每个元素都携带自己的剩余扁平化深度，这样就能完美回溯层级。

function flatten(arr, depth = 1) {
  // 初始化栈，每个元素是[待处理值, 剩余深度]
  const stack = arr.map(item => [item, depth]);
  const result = [];

  while (stack.length > 0) {
    const [elem, currentDepth] = stack.pop();
    if (Array.isArray(elem) && currentDepth > 0) {
      // 倒序推入栈，保证最终结果的顺序和原数组一致
      stack.push(...elem.map(item => [item, currentDepth - 1]));
    } else {
      result.push(elem);
    }
  }
  // 因为栈是后进先出，所以反转结果得到正确顺序
  return result.reverse();
}

测试你的用例：

flatten([[1],2,[[3], 'ddd', [4,[5]]]], 2);
// 输出：[1,2,3,'ddd',4, [5]]，完全符合期望

方案2：调整你原有的数组拼接逻辑 #

如果你不想用栈，也可以把原代码改成用队列来跟踪元素和对应的深度，避免全局深度变量的干扰：

function flatten(arr, depth = 1) {
  let flat = [];
  // 用队列存储待处理的元素和对应的剩余深度
  const queue = arr.map(item => [item, depth]);
  
  while (queue.length > 0) {
    // 从队列头部取出元素，保证顺序和原数组一致
    const [elem, currentDepth] = queue.shift();
    if (Array.isArray(elem) && currentDepth > 0) {
      // 将子元素带着"深度-1"插入队列头部，优先处理
      queue.unshift(...elem.map(item => [item, currentDepth - 1]));
    } else {
      flat.push(elem);
    }
  }
  
  return flat;
}

核心思路 #

不管用栈还是队列，本质都是给每个待处理元素绑定独立的剩余深度，替代你原代码里的全局深度变量。这样处理嵌套数组时，每个层级的元素都知道自己还能被扁平化几次，不会出现深度回溯失败的问题。

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