Question

有一个对象和一个数组。

list: [
  {
    oldData: {
      title: 'abc',
      id: 1,
      date: '1982-09-30',
      budget: 250000,
    },
    newData: [
      {
        key: 1,
        data: null,
        value: 5,
      },
      {
        key: 2,
        data: null,
        value: 22,
      },
      ...
    ],
  },
  {
    oldData: {
      title: 'blablablaaaaa',
      id: 2,
      date: '2012-02-23',
      budget: 350000,
    },
    newData: [
      {
        key: 1,
        data: null,
        value: 35,
      },
      {
        key: 2,
        data: null,
        value: 41,
      },
      ...
    ],
  },
  ... some more datas...
]

如上所述，有更多相同类型的数据。

我需要一起使用oldData and newData，所以我想将两者结合起来。

如何合并oldData and newData，以便有多组oldData and newData pairs？

例如，[{ combineData: {...} }, { combineData: {...} }, ... }]在这里。

我知道如何将数组与数组，对象与对象结合在一起，但是我不知道该怎么做。

有什么好的解决方法吗？

Answer 1

您可以在阵列上使用map()。然后使用Object.assign()和散布运算符将newData中所有元素的所有属性组合到一个对象中。

const arr = [
  {
    oldData: {
      a:10,
      b:20
    },
    newData: [
      {
        c:30,
        d:40
      },
      {
        e:50,
        f:60
      }
    ],
  }
]
const res = arr.map(x => ({combinedData:{...x.oldData, ...Object.assign({}, ...x.newData)}}))
               
console.log(res)

Answer 2

您可以映射到数组并使用对象分解（...object）创建一个新的组合对象：

const data = [
  {
    oldData: {
      foo: 'lorem',
    },
    newData: {
      bar: 'ipsum',
    },
  },
  {
    oldData: {
      foo: 'dolor',
    },
    newData: {
      bar: 'sit amet',
    },
  },
];

const combined = data.map(record => ({...record.oldData, ...record.newData}));
console.log(combined);

但是，这将覆盖重复的键，所以类似：

{
  oldData: {
    message: 'a',
  },
  newData: {
    message: 'b',
  },
}

将变为：

{
  message: 'b',
}

Answer 3

您所期望的结果尚不清楚，但是您确实说过想要旧的/新的对。此答案与其他答案不同，它生成由旧/新对组成的组合数据对象的数组，其中oldData值被复制以便与列表中每个对应的newData值并排出现项目。

第一个问题更新后的原始数据：

let list = [
   {
    oldData: { title: 'abc', id: 1, date: '1982-09-30', budget: 250000 },
    newData: [
      { key: 1, data: null, value: 5  },
      { key: 2, data: null, value: 22 },
      //...
    ],
  },
  {
    oldData: { title: 'blablablaaaaa', id: 2, date: '2012-02-23', budget: 350000 },
    newData: [
      { key: 1, data: null, value: 35 },
      { key: 2, data: null, value: 41 },
      //...
    ],
  },
  //... some more datas...
];

此代码将每个{old,new[]}列表项映射为成对的[{old,new}, {old,new}, ...]对数组，这些对数组在最终的reduce()调用中组合在一起：

var combinedDatas = list
    .map(listItem => listItem.newData.map(newItem => ({ 
        oldData: listItem.oldData, 
        newData: newItem 
    })))
    .reduce();

console.log(JSON.stringify(oldNewCombos, null, 4));

生成非标准化对的列表：

[
    { list[0].oldData, list[0].newData[0] }, 
    { list[0].oldData, list[0].newData[1] },
    //...rest of list[0] oldData with newData[n] combos

    { list[1].oldData, list[1].newData[0] }, 
    { list[1].oldData, list[1].newData[1] },
    //...rest of list[1] oldData with newData[n] combos

    { list[2].oldData, list[2].newData[0] }, 
    { list[2].oldData, list[2].newData[1] },
    //...rest of list[2] oldData with newData[n] combos

    //...
]

有没有一种在JavaScript中组合数组和对象的好方法？

3 个答案: