如何将深度嵌套对象转换为对象数组？

方法一：迭代循环（推荐，避免深层嵌套栈溢出） #

通过迭代遍历每一层的parent，逐步提取所需字段并加入结果数组，直到parent为null：

function flattenNestedParent(obj) {
  const result = [];
  let currentNode = obj;
  
  while (currentNode) {
    // 解构当前对象，排除parent属性，保留其他字段
    const { parent, ...nodeData } = currentNode;
    result.push(nodeData);
    // 移动到下一层父节点
    currentNode = parent;
  }
  
  return result;
}

方法二：递归实现（代码更简洁） #

如果嵌套层级不会特别深，递归写法会更直观：

function flattenNestedParentRecursive(obj, result = []) {
  if (!obj) return result;
  
  const { parent, ...nodeData } = obj;
  result.push(nodeData);
  
  return flattenNestedParentRecursive(parent, result);
}

测试示例 #

用你提供的嵌套对象测试：

const nestedObj = {
  name: '1',
  address: '1',
  parent: {
    name: '2',
    address: '2',
    parent: {
      name: '3',
      address: '3',
      parent: {
        name: '4',
        address: '4',
        parent: {
          name: '5',
          address: '5',
          parent: null,
        },
      },
    },
  },
};

// 调用函数
console.log(flattenNestedParent(nestedObj));
// 输出结果与你期望的一致：
// [ { name: '1', address: '1' }, { name: '2', address: '2' }, ..., { name: '5', address: '5' } ]

这两种方法都能可靠地处理任意层级的嵌套结构，迭代循环更适合极深的嵌套场景（避免递归栈溢出），递归写法则更简洁易读。

内容的提问来源于stack exchange，提问作者Rodrigo Bazan Danino