Question

我有一个具有这种形状的数据结构：

[
  {
    a: "x",
    val: [
      { b: "y1", val: [1, 2, 3] },
      { b: "y2", val: [4, 5, 6] },
    ],
  },
];

3 个级别的示例：

[
  {
    a: "x",
    val: [
      { b: "y1", val: [
        {c: "z1", val: [1, 2]}
      ] },
      { b: "y2", val: [
        { c: "z2", val: [3, 4] },
        { c: "z3", val: [5, 6, 7] },
        { c: "z4", val: [8] }
      ]  },
    ],
  },
];

每个对象总是有相同级别的嵌套，我提前知道最大嵌套深度。我们也提前知道键的名称：我们知道级别 1 的键将命名为 a，级别 2 的键将命名为 b，依此类推。

我希望创建一个函数，将第一个示例转换为：

[
    {
      a: "x",
      b: "y1",
      val: [1, 2, 3],
    },
    {
      a: "x",
      b: "y2",
      val: [4, 5, 6],
    },
];

即一个平面数组，其值和键从父级继承。

我有一个适用于第一个示例的解决方案：

const res = [
  {
    a: "x",
    val: [
      { b: "y1", val: [1, 2, 3] },
      { b: "y2", val: [4, 5, 6] },
    ],
  },
].flatMap((x) => x.val.flatMap((d) => ({ a: x.a, ...d })));
console.log(res);

但我正在努力把它变成一个递归函数。

预先感谢您的帮助！

Answer 1

您可以查看数组，如果里面没有对象返回一个对象，则通过存储其他属性来映射 val 属性。

const
    isObject = o => o && typeof o === 'object',
    flat = array => {
        if (!array.every(isObject)) return { val: array };
        return array.flatMap(({ val, ...o }) => {
            const temp = flat(val);
            return Array.isArray(temp)
                ? temp.map(t => ({ ...o, ...t }))
                : { ...o, ...temp };
        });
    },
    data0 = [{ a: "x", val: [{ b: "y1", val: [1, 2, 3] }, { b: "y2", val: [4, 5, 6] }] }],
    data1 = [{ a: "x", val: [{ b: "y1", val: [{ c: "z1", val: [1, 2] }] }, { b: "y2", val: [{ c: "z2", val: [3, 4] }, { c: "z3", val: [5, 6, 7] }, { c: "z4", val: [8] }] }] }];

console.log(flat(data0));
console.log(flat(data1))

.as-console-wrapper { max-height: 100% !important; top: 0; }

展平嵌套对象，保留父对象的属性

1 个答案: