现在有点晚了，但也许有人喜欢这个。

ES6:

常量用户=[{name：“Jim”，颜色：“蓝色”},{name：“Sam”，颜色：“蓝色”},{name：“Eddie”，颜色：“绿色”},{姓名：“Robert”，颜色：“绿色”},];常量groupBy=（arr，key）=>{const initialValue=｛｝；返回arr.reduce（（acc，cval）=>{const myAttribute=cval[key]；acc[myAttribute]=[…（acc[myAattribute]| |[]），cval]返回acc；}，initialValue）；};const res=groupBy（用户，“颜色”）；console.log（“分组依据：”，res）；

这里有一个ES6版本，不会在空成员上中断

function groupBy (arr, key) {
  return (arr || []).reduce((acc, x = {}) => ({
    ...acc,
    [x[key]]: [...acc[x[key]] || [], x]
  }), {})
}

在Joseph Nields的回答之后，有一个polyfill用于将对象分组https://github.com/padcom/array-prototype-functions#arrayprototypegroupbyfieldormapper.因此，您可能希望使用现有的内容，而不是一次又一次地编写这些内容。

/***数组分组依据*@类别数组*@function arrayGroupBy*@return｛object｝｛“fieldName”：〔｛…｝〕，…｝*@静态*@作者hht*@param｛string｝｝密钥组密钥*@param｛array｝数据数组**@示例01* --------------------------------------------------------------------------*从“@xx/utils”导入｛arrayGroupBy｝；*常量数组=[* {*type：'资产'，*name:'zhangsan'，*年龄：33岁，* },* {*类型：'config'，*name:“a”，*年龄：13岁，* },* {*类型：'run'，*名称：'lisi'，*年龄：“3”，* },* {*类型：'xx'，*name:'timo'，*年龄：'4'，* },*];*arrayGroupBy（array，'type'，）；**结果：{*资产：[{年龄：'33'，名称：'zhangsan'，类型：'assets'}]，*config:[｛age:“13”，名称：“a”，类型：“config”｝]，*运行：[｛age:“3”，名称：“lisi”，类型：“run”｝]，*xx:[｛age:“4”，名称：“timo”，类型：“xx”｝]，* };**@example示例02 null* --------------------------------------------------------------------------*常量数组=空；*arrayGroupBy（数组，“类型”）；**结果：｛｝**@example示例03键取消绑定* --------------------------------------------------------------------------*常量数组=[* {*type：'资产'，*name:'zhangsan'，*年龄：33岁，* },* {*类型：'config'，*name:“a”，*年龄：13岁，* },* {*类型：'run'，*名称：'lisi'，*年龄：“3”，* },* {*类型：'xx'，*name:'timo'，*年龄：'4'，* },*];*arrayGroupBy（数组，“xx”）；** {}**/const arrayGroupBy=（data，key）=>{if（！data||！Array.isArray（data））返回｛｝；常量groupObj={}；data.forEach（（项）=>{if（！item[key]）返回；const fieldName=项[key]；if（！groupObj[fieldName]）{groupObj[fieldName]=[item]；回来}groupObj[fieldName].push（项）；});返回groupObj；};常量数组=[{type：'资产'，name:'zhangsan'，年龄：33岁，},{类型：'config'，name:“a”，年龄：13岁，},{类型：'run'，名称：'lisi'，年龄：“3”，},{类型：'run'，名称：“wangmazi”，年龄：“3”，},{类型：'xx'，name:'timo'，年龄：'4'，},];console.dir（arrayGroupBy（array，'type'））<p>description（'arrayGroupBy match'，（）=>{常量数组=[{type：'资产'，name:'zhangsan'，年龄：33岁，},{类型：'config'，name:“a”，年龄：13岁，},{类型：'run'，名称：'lisi'，年龄：“3”，},{类型：'xx'，name:'timo'，年龄：'4'，},];测试（'arrayGroupBy…'，（）=>{常量结果={资产：[{年龄：'33'，名称：'zhangsan'，类型：'assets'}]，config:[｛age:“13”，名称：“a”，类型：“config”｝]，运行：[｛age:“3”，名称：“lisi”，类型：“run”｝]，xx:[｛age:“4”，名称：“timo”，类型：“xx”｝]，};expect（arrayGroupBy（array，'type'））.toEqual（result）；});test（'arrayGroupBy不匹配..'，（）=>{//结果expect（arrayGroupBy（array，'xx'））.toEqual（{}）；});test（'arrayGroupBy null'，（）=>{let数组=空；expect（arrayGroupBy（array，'type'））.toEqual（｛｝）；});test（'arrayGroupBy undefined'，（）=>{let array=未定义；expect（arrayGroupBy（array，'type'））.toEqual（｛｝）；});test（'arrayGroupBy空'，（）=>{let数组=[]；expect（arrayGroupBy（array，'type'））.toEqual（｛｝）；});});</p>

使用linq.js可能更容易做到这一点，它是linq在JavaScript（DEMO）中的真正实现：

var linq = Enumerable.From(data);
var result =
    linq.GroupBy(function(x){ return x.Phase; })
        .Select(function(x){
          return {
            Phase: x.Key(),
            Value: x.Sum(function(y){ return y.Value|0; })
          };
        }).ToArray();

结果：

[
    { Phase: "Phase 1", Value: 50 },
    { Phase: "Phase 2", Value: 130 }
]

或者，更简单地使用基于字符串的选择器（DEMO）：

linq.GroupBy("$.Phase", "",
    "k,e => { Phase:k, Value:e.Sum('$.Value|0') }").ToArray();

我对公认的答案进行了扩展，包括按多个财产分组，然后再加上，使其完全起作用，没有变异。观看演示https://stackblitz.com/edit/typescript-ezydzv

export interface Group {
  key: any;
  items: any[];
}

export interface GroupBy {
  keys: string[];
  thenby?: GroupBy;
}

export const groupBy = (array: any[], grouping: GroupBy): Group[] => {
  const keys = grouping.keys;
  const groups = array.reduce((groups, item) => {
    const group = groups.find(g => keys.every(key => item[key] === g.key[key]));
    const data = Object.getOwnPropertyNames(item)
      .filter(prop => !keys.find(key => key === prop))
      .reduce((o, key) => ({ ...o, [key]: item[key] }), {});
    return group
      ? groups.map(g => (g === group ? { ...g, items: [...g.items, data] } : g))
      : [
          ...groups,
          {
            key: keys.reduce((o, key) => ({ ...o, [key]: item[key] }), {}),
            items: [data]
          }
        ];
  }, []);
  return grouping.thenby ? groups.map(g => ({ ...g, items: groupBy(g.items, grouping.thenby) })) : groups;
};