如何将嵌套对象展平为对象数组答案

【问题标题】：How to flatten nested object to an array of objects如何将嵌套对象展平为对象数组
【发布时间】：2021-11-06 06:33:16
【问题描述】：

我需要将嵌套对象展平为对象数组。到目前为止，这就是我想出的。但它不能正常工作。目前我正在检查当前元素是否为对象，如果它是我正在递归调用相同函数的对象。

作为输出我需要这个。

[
 {title: 'Foo', value: 111},
 {title: 'Bar', value: 222},
 ...
]

var data = {
  1: {
    title: "Foo",
    value: 111,
    children: {
      2: {
        title: "Bar",
        value: 222,
      },
    },
  },
  3: {
    title: "Baz",
    value: 333,
    children: {
      4: {
        title: "Qux",
        value: 444,
        children: {
          5: {
            title: "Quux",
            value: 555,
          },
        },
      },
    },
  },
};

const finalArrayOfObjects = [];

  const flattenObject = (obj) => {
    const flattened = {};

    Object.keys(obj).forEach((key) => {
      if (typeof obj[key] === "object" && obj[key] !== null) {
        flattenObject(obj[key]);
      } else {
        flattened[key] = obj[key];
      }

      finalArrayOfObjects.push(flattened);
      console.log(flattened);
    });
  };

【问题讨论】：

stackoverflow.com/questions/30048388/… 可能会有所帮助

标签： javascript

【解决方案1】：

这是一种方法，使用递归生成器函数。

var data = {
  1: {
    title: "Foo",
    value: 111,
    children: {
      2: {
        title: "Bar",
        value: 222,
      },
    },
  },
  3: {
    title: "Baz",
    value: 333,
    children: {
      4: {
        title: "Qux",
        value: 444,
        children: {
          5: {
            title: "Quux",
            value: 555,
          },
        },
      },
    },
  },
};

function *forAllChildren(obj) {
  for (let key in obj) {
    let { children, ...objWithoutChildren} = obj[key];
    yield objWithoutChildren;
    yield *forAllChildren(obj[key].children);
  }
}

const result = [...forAllChildren(data)]
console.log(result);

【讨论】：

【解决方案2】：

希望这对你有用

var finalArrayOfObjects = [];

var flattenObject = (obj) => {

    for(var key in obj) {
        // { title , value, children}
        var data = obj[key]
        if (data.children) {
            // data.children = { key : {title , value, children} }
            flattenObject(data.children)
        }
        finalArrayOfObjects.push({
            title : data.title,
            value : data.value,
        })
    }
}
flattenObject(data)
console.log(finalArrayOfObjects)

【讨论】：

【解决方案3】：

是时候再次证明函数式编程和递归的力量

var data = {
        1: {
          title: "Foo",
          value: 111,
          children: {
            2: {
              title: "Bar",
              value: 222,
            },
          },
        },
        3: {
          title: "Baz",
          value: 333,
          children: {
            4: {
              title: "Qux",
              value: 444,
              children: {
                5: {
                  title: "Quux",
                  value: 555,
                },
              },
            },
          },
        },
      };

  const dictAsArray = Object.values(data);
  const flat = [];

  function drill(array) {
    array.map(obj => {
       recursiveCall(obj);
      });
   }

  function recursiveCall(obj) {
    if (obj.children) {
      const children = JSON.parse(JSON.stringify(Object.values(obj.children)));
      delete obj.children; 
      drill(children);
    }

    flat.push(obj);
  }

  dictAsArray.map(dict => recursiveCall(dict));
  console.log(flat);

在这种方法中，子对象从每个对象中删除。如果您希望它们保留，您可以简单地删除 delete obj.children。

【讨论】：