如何遍历嵌套对象数组生成含层级与父ID的对象数组？

非递归实现（推荐，避免递归复杂度） #

用栈模拟递归过程，逐层处理每个节点，无需担心递归深度限制：

function flattenTree(treeData) {
  const result = [];
  // 栈元素格式：{ node: 节点对象, parentId: 父节点name, level: 当前层级 }
  const stack = [];

  // 初始化顶层节点
  treeData.forEach(node => {
    stack.push({ node, parentId: null, level: 0 });
  });

  while (stack.length > 0) {
    const { node, parentId, level } = stack.pop();
    // 生成目标对象
    const item = {
      id: node.name,
      label: node.name,
      level
    };
    // 非顶层节点添加parentId
    if (parentId !== null) {
      item.parentId = parentId;
    }
    result.push(item);

    // 反向遍历children，保证处理顺序和原结构一致（栈是后进先出）
    for (let i = node.children.length - 1; i >= 0; i--) {
      stack.push({
        node: node.children[i],
        parentId: node.name,
        level: level + 1
      });
    }
  }

  return result;
}

// 测试数据
const input = {
  "count": 3,
  "tree": [
    {
      "name": "Parent1a",
      "children": [
        {
          "name": "Child1a",
          "children": [
            {
              "name": "Child2a",
              "children": [
                {
                  "name": "Child3a",
                  "children": [
                    {
                      "name": "Child4a",
                      "children": []
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    },
    {
      "name": "Parent1b",
      "children": [
        {
          "name": "Child1b",
          "children": []
        }
      ]
    }
  ]
};

// 调用函数
const output = flattenTree(input.tree);
console.log(output);

递归实现（简洁但需注意层级深度） #

如果能理解基础递归逻辑，这个写法更简洁：

function flattenTreeRecursive(treeData, parentId = null, level = 0) {
  let result = [];
  treeData.forEach(node => {
    // 生成当前节点
    const item = {
      id: node.name,
      label: node.name,
      level
    };
    if (parentId !== null) {
      item.parentId = parentId;
    }
    result.push(item);
    // 递归处理子节点
    if (node.children.length > 0) {
      result = result.concat(flattenTreeRecursive(node.children, node.name, level + 1));
    }
  });
  return result;
}

// 调用方式
const outputRecursive = flattenTreeRecursive(input.tree);
console.log(outputRecursive);

关键说明 #

• 非递归版本用栈存储待处理节点，每个节点处理时生成目标对象，再将子节点推入栈，完全模拟递归的遍历顺序
• 递归版本通过函数自身调用处理子节点，代码更短，但如果树形结构层级极深（比如超过1000层），可能触发栈溢出
• 两种实现都会生成你需要的结构：顶层节点level=0无parentId，子节点level逐层递增，parentId对应父节点的name

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