将对象数组转换为包含对象的数组数组的最佳方法

Question

以这个极其简化的对象数组为例：

[
    {
      createID: '1'
      // Many other properties...
    },
    {
      createID: '1'
      // Many other properties...
    },
    {
      createID: '1'
      // Many other properties...
    },
    {
      createID: '37'
      // Many other properties...
    },
    {
      createID: '37'
      // Many other properties...
    },
    {
      createID: '2'
      // Many other properties...
    },
    {
      createID: '2'
      // Many other properties...
    },
    {
      createID: '14'
      // Many other properties...
    },
  ];

给定这个数组，然后我使用对象createID 属性创建一个包含对象[[{..},{..}], [{..}], ..n] 的数组数组。我正在使用的当前前端框架（Angular v6）需要这种最终格式。

为了完成这项任务，我使用以下代码，其中tempArr 是一个类似于上面提供的示例数组的数组。

    let currentGroup: string = tempArr[0].createID;
    let tempGrouped: any[] = [];
    let childGroup: any[] = [];
    tempArr.forEach(item => {
      if (item.createID !== currentGroup) {
        tempGrouped.push(childGroup);
        childGroup = [];
        currentGroup = item.createID;
      }
      childGroup.push(item);
    });
    tempGrouped.push(childGroup);

此代码运行良好。但是，我不禁相信必须有一种更高效、更优雅的方法，将对象数组转换为包含对象的数组。

更新

请务必注意，createID 的 只是表示应将哪些对象组合在一起的 id。 因此，它们不需要按createID 进行数字排序。此外，正如您在提供的给定示例数组中所见，这些对象确实来自与其兄弟对象（相同的createID）“分组”的服务器。

Answer 1

您的示例具有彼此相邻的所有相同 ID。如果保证始终如此，那么您只需要循环并推送到新数组即可。但是，如果不是这种情况，您的解决方案将无法正确分组项目。在这种情况下，使用哈希表将允许您仍然按具有相同渐近复杂度的 ID 进行分组。

您可以使用从createdID 创建的键将您的对象分组到一个哈希表对象中。这将使您有效地对所有内容进行分组。然后从哈希表中取出对象：

let arr = [{createID: '1'},{createID: '1'},{createID: '1'},{createID: '37'},{createID: '37'},{createID: '2'},{createID: '2'},{createID: '14'},];

let o = arr.reduce((a, c) => {
    (a[c.createID] || (a[c.createID] = [])).push(c)
    return a
}, {} )
// o is a an object with createID keys pointing to arrays of grouped objects
// just take the values
console.log(Object.values(o))

根据问题编辑编辑

由于对象已经被分组，没有比循环遍历更好的方法了。如果您想要一个不添加临时数组的选项，您仍然可以使用reduce()，这与您当前的解决方案基本相同，但可能更独立：

let tempArr = [{createID: '1'},{createID: '1'},{createID: '1'},{createID: '37'},{createID: '37'},{createID: '2'},{createID: '2'},{createID: '14'},];

let r = tempArr.reduce((a, c, i, self) => {
    if (i === 0 || self[i-1].createID !== c.createID) 
        a.push([])
    a[a.length - 1].push(c)
    return a
}, [])

console.log(r)

Answer 2

假设您的数据数组存储在名为data 的变量中：

  const result = data.reduce((acc, current) => {
    if (!acc.dictionary[current.createID]) {
      const createIdArray = [];
      acc.dictionary[current.createID] = createIdArray;
      acc.array.push(createIdArray);
    }

    acc.dictionary[current.createID].push(current);

    return acc;
  }, {array: [], dictionary: {}}).array;

这样，您只需对数据循环一次，而且效率很高，因为我们不使用过滤器或查找（它会一次又一次地遍历整个数组）。

这是输出：

[
  [
    {
      createID: '1',
    },
    {
      createID: '1',
    },
    {
      createID: '1',
    },
  ],
  [
    {
      createID: '37',
    },
    {
      createID: '37',
    },
  ],
  [
    {
      createID: '2',
    },
    {
      createID: '2',
    },
  ],
  [
    {
      createID: '14',
    },
  ],
];

这是一个正在运行的演示：https://stackblitz.com/edit/typescript-phbzug

总结：

• 字典是自包含在 reduce 函数中的，这意味着一旦 reduce 完成，它就会被垃圾回收
• 不依赖任何外部变量，更容易推理和 IMO 更好的做法
• 这个解决方案更健壮（数组不需要排序）~与 OP 的答案相同的行数
• 干净：使用字典，您可以直接了解您正在访问的内容，而且速度非常快

Answer 3

您想按 createID 分组吗？

let grouped=tempArray
//first get uniq values
.filter((s,index)=>tempArray.findIndex(f=>f.createID==s.createID)==index)
//then, with the uniq values make a map       
.map(seg=>{  //with each uniq value, create an object with two properties
   return {
      createID:seg.createID,  //the key
      items:tempArray.filter(s=>s.createID==seg.createID) //An array with the values
   }
})