我对公认的答案进行了扩展，包括按多个财产分组，然后再加上，使其完全起作用，没有变异。观看演示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;
};

function groupBy(array, groupBy){
        return array.reduce((acc,curr,index,array) => {
           var  idx = curr[groupBy]; 
              if(!acc[idx]){
                    acc[idx] = array.filter(item => item[groupBy] === idx)
              } 
            return  acc; 

        },{})
    }

// call
groupBy(items,'Step')

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

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

发帖是因为即使这个问题已经7年了，我仍然没有看到一个符合原始标准的答案：

我不希望它们“拆分”，而是“合并”，更像SQL组方法

我最初发表这篇文章是因为我想找到一种方法来减少对象数组（例如，当您从csv中读取时创建的数据结构），并通过给定索引聚合以生成相同的数据结构。我正在寻找的返回值是另一个对象数组，而不是我在这里看到的嵌套对象或映射。

下面的函数获取一个数据集（对象数组）、一个索引列表（数组）和一个reducer函数，并将reducer功能应用于索引的结果作为一个对象数组返回。

function agg(data, indices, reducer) {

  // helper to create unique index as an array
  function getUniqueIndexHash(row, indices) {
    return indices.reduce((acc, curr) => acc + row[curr], "");
  }

  // reduce data to single object, whose values will be each of the new rows
  // structure is an object whose values are arrays
  // [{}] -> {{}}
  // no operation performed, simply grouping
  let groupedObj = data.reduce((acc, curr) => {
    let currIndex = getUniqueIndexHash(curr, indices);

    // if key does not exist, create array with current row
    if (!Object.keys(acc).includes(currIndex)) {
      acc = {...acc, [currIndex]: [curr]}
    // otherwise, extend the array at currIndex
    } else {
      acc = {...acc, [currIndex]: acc[currIndex].concat(curr)};
    }

    return acc;
  }, {})

  // reduce the array into a single object by applying the reducer
  let reduced = Object.values(groupedObj).map(arr => {
    // for each sub-array, reduce into single object using the reducer function
    let reduceValues = arr.reduce(reducer, {});

    // reducer returns simply the aggregates - add in the indices here
    // each of the objects in "arr" has the same indices, so we take the first
    let indexObj = indices.reduce((acc, curr) => {
      acc = {...acc, [curr]: arr[0][curr]};
      return acc;
    }, {});

    reduceValues = {...indexObj, ...reduceValues};


    return reduceValues;
  });


  return reduced;
}

我将创建一个返回count（*）和sum（Value）的reducer：

reducer = (acc, curr) => {
  acc.count = 1 + (acc.count || 0);
  acc.value = +curr.Value + (acc.value|| 0);
  return acc;
}

最后，使用我们的reducer将agg函数应用于原始数据集会生成一个应用了适当聚合的对象数组：

agg(tasks, ["Phase"], reducer);
// yields:
Array(2) [
  0: Object {Phase: "Phase 1", count: 4, value: 50}
  1: Object {Phase: "Phase 2", count: 4, value: 130}
]

agg(tasks, ["Phase", "Step"], reducer);
// yields:
Array(4) [
  0: Object {Phase: "Phase 1", Step: "Step 1", count: 2, value: 15}
  1: Object {Phase: "Phase 1", Step: "Step 2", count: 2, value: 35}
  2: Object {Phase: "Phase 2", Step: "Step 1", count: 2, value: 55}
  3: Object {Phase: "Phase 2", Step: "Step 2", count: 2, value: 75}
]

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

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 Map对象：

/***@描述*采用Array＜V＞和分组函数，*并返回由分组函数分组的数组的Map。**@param list V类型的数组。*@param keyGetter一个函数，将数组类型V作为输入，并返回类型K的值。*K通常是V的属性键。**@返回由分组函数分组的数组的映射。*///导出函数组By＜K，V＞（列表：Array＜V＞，keyGetter：（输入：V）=>K）：Map＜K，Array＜V>>{//const-map=new map<K，Array<V>>（）；函数groupBy（list，keyGetter）{const-map=new map（）；list.forEach（（项）=>{const key=keyGetter（项）；constcollection=map.get（key）；if（！集合）{map.set（键，[项]）；}其他{collection.push（项）；}});回归图；}//示例用法常量宠物=[｛type:“Dog”，name:“Spot”｝，{类型：“猫”，名称：“老虎”}，{类型：“狗”，名称：“路虎”}，｛类型：“猫”，名称：“利奥”｝];const grouped=groupBy（宠物，宠物=>宠物类型）；console.log（分组.get（“Dog”））；//->〔｛类型：“狗”，名称：“斑点”｝，｛类型“狗”、名称：“漫游者”｝〕console.log（分组.get（“Cat”））；//->〔｛类型：“猫”，名称：“老虎”｝，｛类型“猫”、名称：“狮子座”｝〕const奇数=符号（）；const even=符号（）；常量=[1,2,3,4,5,6,7]；const oddEven=groupBy（数字，x=>（x%2===1？奇数：偶数））；console.log（oddEven.get（奇数））；//->[1,3,5,7]console.log（oddEven.get（偶数））；//->[2,4,6]

关于地图：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map