您可以从array.reduce（）构建ES6映射。

const groupedMap = initialArray.reduce(
    (entryMap, e) => entryMap.set(e.id, [...entryMap.get(e.id)||[], e]),
    new Map()
);

这与其他解决方案相比有一些优势：

它不需要任何库（与例如_.groupBy（）不同）您得到的是JavaScript Map而不是对象（例如，由_.groupBy（）返回）。这有很多好处，包括：它会记住第一次添加项目的顺序，键可以是任何类型，而不仅仅是字符串。Map是比数组数组更有用的结果。但是，如果确实需要数组数组，则可以调用array.from（groupedMap.entries（））（对于[key，group array]对的数组）或array.from（groupedMap.values（）），（对于简单的数组数组）。它非常灵活；通常情况下，您计划使用此地图进行的任何操作都可以作为缩减的一部分直接完成。

作为最后一点的示例，假设我有一个对象数组，我想按id对其进行（浅）合并，如下所示：

const objsToMerge = [{id: 1, name: "Steve"}, {id: 2, name: "Alice"}, {id: 1, age: 20}];
// The following variable should be created automatically
const mergedArray = [{id: 1, name: "Steve", age: 20}, {id: 2, name: "Alice"}]

要做到这一点，我通常首先按id分组，然后合并每个结果数组。相反，您可以直接在reduce（）中执行合并：

const mergedArray = Array.from(
    objsToMerge.reduce(
        (entryMap, e) => entryMap.set(e.id, {...entryMap.get(e.id)||{}, ...e}),
        new Map()
    ).values()
);

稍后编辑：

对于大多数目的来说，上述方法可能足够有效。但最初的问题是“最有效”的，正如一些人所指出的，上述解决方案并非如此。问题主要是为每个条目实例化一个新数组。我本以为JS解释器会优化这一点，但似乎并非如此。

有人建议进行编辑来解决这个问题，但看起来确实更复杂。原始代码段已经有点提高了可读性。如果你真的想这样做，请使用for循环！这不是罪！它需要一到两行代码，但它比函数技术更简单，尽管它并不短：

groupedMap = new Map();
for (const e of initialArray) {
    if (groupedMap.has(e.id)) {
        groupedMap.get(e.id).push(e)
    }
    else {
        groupedMap.set(e.id, [e])
    }
}

这里有一个使用ES6的讨厌的、难以阅读的解决方案：

export default (arr, key) => 
  arr.reduce(
    (r, v, _, __, k = v[key]) => ((r[k] || (r[k] = [])).push(v), r),
    {}
  );

对于那些询问这是如何工作的人，这里有一个解释：

在这两个=>中，您可以获得免费回报Array.prototype.reduce函数最多包含4个参数。这就是为什么要添加第五个参数，这样我们就可以使用默认值在参数声明级别为组（k）创建一个廉价的变量声明。（是的，这是巫术）如果我们的当前组在上一次迭代中不存在，我们将创建一个新的空数组（（r[k]||（r[k]=[]））。这将计算到最左边的表达式，换句话说，一个现有数组或一个空数组，这就是为什么在该表达式之后会立即推送，因为无论哪种方式都会得到一个数组。当有一个返回时，逗号运算符将丢弃最左边的值，返回该场景中经过调整的前一组。

更容易理解的版本是：

export default (array, key) => 
  array.reduce((previous, currentItem) => {
    const group = currentItem[key];
    if (!previous[group]) previous[group] = [];
    previous[group].push(currentItem);
    return previous;
  }, {});

编辑：

TS版本：

const groupBy = <T, K extends keyof any>(list: T[], getKey: (item: T) => K) =>
  list.reduce((previous, currentItem) => {
    const group = getKey(currentItem);
    if (!previous[group]) previous[group] = [];
    previous[group].push(currentItem);
    return previous;
  }, {} as Record<K, T[]>);

我会检查一下lodash组，它似乎正是你想要的。它也很轻，非常简单。

Fiddle示例：https://jsfiddle.net/r7szvt5k/

如果数组名称为arr，则带有lodash的groupBy仅为：

import groupBy from 'lodash/groupBy';
// if you still use require:
// const groupBy = require('lodash/groupBy');

const a = groupBy(arr, function(n) {
  return n.Phase;
});
// a is your array grouped by Phase attribute

让我们生成一个通用的Array.protocol.groupBy（）工具。为了多样化，让我们在递归方法上使用ES6 fancyty扩展运算符进行Haskell式模式匹配。同样，让我们让Array.prototype.groupBy（）接受一个回调，该回调将项（e）、索引（i）和应用的数组（a）作为参数。

Array.prototype.groupBy=函数（cb）{返回函数迭代（[x，…xs]，i=0，r=[[]，[]]）{cb（x，i，[x，…xs]）？（r[0].推（x），r）：（r[1].推（x），r）；是否返回xs.length？迭代（xs，++i，r）：r；}（本）；};var arr=[0,1,2,3,4,5,6,7,8,9]，res=arr.groupBy（e=>e<5）；console.log（res）；

_.groupBy([{tipo: 'A' },{tipo: 'A'}, {tipo: 'B'}], 'tipo');
>> Object {A: Array[2], B: Array[1]}

发件人：http://underscorejs.org/#groupBy

data = [{id:1, name:'BMW'}, {id:2, name:'AN'}, {id:3, name:'BMW'}, {id:1, name:'NNN'}]
key = 'id'//try by id or name
data.reduce((previous, current)=>{
    previous[current[key]] && previous[current[key]].length != 0 ? previous[current[key]].push(current) : previous[current[key]] = new Array(current)
    return previous;
}, {})