无突变：

const groupBy = (xs, key) => xs.reduce((acc, x) => Object.assign({}, acc, {
  [x[key]]: (acc[x[key]] || []).concat(x)
}), {})

console.log(groupBy(['one', 'two', 'three'], 'length'));
// => {3: ["one", "two"], 5: ["three"]}

使用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

正确答案——只是浅分组。理解减少是很好的。问题还提供了额外总计计算的问题。

这里是一个由一些字段组成的对象数组的REAL GROUP BY，该字段具有1）计算的键名称和2）通过提供所需键的列表来实现分组级联的完整解决方案并将其唯一值转换为根键，如SQL GROUP BY做

常量inputArray=[｛阶段：“阶段1”，步骤：“步骤1”，任务：“任务1”，值：“5”｝，｛阶段：“阶段1”，步骤：“步骤1”，任务：“任务2”，值：“10”｝，｛阶段：“阶段1”，步骤：“步骤2”，任务：“任务1”，值：“15”｝，｛阶段：“阶段1”，步骤：“步骤2”，任务：“任务2”，值：“20”｝，｛阶段：“阶段2”，步骤：“步骤1”，任务：“任务1”，值：“25”｝，｛阶段：“阶段2”，步骤：“步骤1”，任务：“任务2”，值：“30”｝，｛阶段：“阶段2”，步骤：“步骤2”，任务：“任务1”，值：“35”｝，｛阶段：“阶段2”，步骤：“步骤2”，任务：“任务2”，值：“40”｝];var outObject=inputArray.reduce（函数（a，e）{//GROUP BY估计密钥（estKey）可能只是一个普通密钥//a——累加器结果对象//e——依次检查的元素，即在此位置测试的元素//可以计算新的分组名称，但必须基于实字段的实际值设estKey=（e['Phase']）；（a[estKey]？a[estKey]：（a[est Key]=null | |[]））.push（e）；返回a；}, {});console.log（outObject）；

使用estKey--您可以按多个字段分组，添加其他聚合、计算或其他处理。

您还可以递归地分组数据。例如，最初按阶段分组，然后按步骤字段分组等等脂肪休息数据。

常量输入数组=[｛阶段：“阶段1”，步骤：“步骤1”，任务：“任务1”，值：“5”｝，｛阶段：“阶段1”，步骤：“步骤1”，任务：“任务2”，值：“10”｝，｛阶段：“阶段1”，步骤：“步骤2”，任务：“任务1”，值：“15”｝，｛阶段：“阶段1”，步骤：“步骤2”，任务：“任务2”，值：“20”｝，｛阶段：“阶段2”，步骤：“步骤1”，任务：“任务1”，值：“25”｝，｛阶段：“阶段2”，步骤：“步骤1”，任务：“任务2”，值：“30”｝，｛阶段：“阶段2”，步骤：“步骤2”，任务：“任务1”，值：“35”｝，｛阶段：“阶段2”，步骤：“步骤2”，任务：“任务2”，值：“40”｝];/***获取obj WITH属性的SHALLOW副本的小助手*/const rmProp=（obj，prop）=>（（｛[prop]：_，…rest｝）=>rest）（obj））/***按关键字分组数组。结果数组的根键是value*指定密钥的。**@param｛Array｝src源数组*@param｛String｝key分组依据的by key*@return｛Object｝将分组对象作为值的对象*/const grpBy=（src，key）=>src.reduce（（a，e）=>(（a[e[key]]=a[e[键]]| |[]）.push（rmProp（e，键）），a), {});/***如果对象数组仅由具有单个值的对象组成，则折叠该数组。*将其替换为剩余值。*/const blowObj=obj=>Array.isArray（obj）&&obj.length==1&&Object.values（obj[0]）.length==1？对象.值（obj[0]）[0]：obj；/***带有键列表的递归分组`keyList`可以是数组*或UNIQUE值将使用逗号分隔的键名列表*成为结果对象的关键点。*/const grpByReal=函数（src，keyList）{const[key，…rest]=Array.isArray（keyList）？keyList:String（keyList）.trim（）.split（/\s*，\s*/）；常量res=键？grpBy（src，key）：[…src]；if（剩余长度）{for（常量k，单位：res）{res[k]=grpByReal（res[k]，其余）}}其他{for（常量k，单位：res）{res[k]=blowObj（res[k]）}}回报率；}console.log（JSON.stringify（grpByReal（inputArray，'阶段，步骤，任务'），null，2））；

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

我会检查声明性js groupBy，它似乎正符合您的要求。它也是：

非常有性能（性能基准）用打字机书写，所以所有打字都包括在内。不强制使用第三方类似数组的对象。

import { Reducers } from 'declarative-js';
import groupBy = Reducers.groupBy;
import Map = Reducers.Map;

const data = [
    { Phase: "Phase 1", Step: "Step 1", Task: "Task 1", Value: "5" },
    { Phase: "Phase 1", Step: "Step 1", Task: "Task 2", Value: "10" },
    { Phase: "Phase 1", Step: "Step 2", Task: "Task 1", Value: "15" },
    { Phase: "Phase 1", Step: "Step 2", Task: "Task 2", Value: "20" },
    { Phase: "Phase 2", Step: "Step 1", Task: "Task 1", Value: "25" },
    { Phase: "Phase 2", Step: "Step 1", Task: "Task 2", Value: "30" },
    { Phase: "Phase 2", Step: "Step 2", Task: "Task 1", Value: "35" },
    { Phase: "Phase 2", Step: "Step 2", Task: "Task 2", Value: "40" }
];

data.reduce(groupBy(element=> element.Step), Map());
data.reduce(groupBy('Step'), Map());

ES6基于reduce的版本，支持iteratee函数。

如果未提供iteratee函数，则工作正常：

const data＝〔｛id:1，得分：2｝，｛id:1，得分：3｝，{id:2，得分：2}，｛id：2，得分：4｝〕常量组=（arr，k）=>arr.reduce（（r，c）=>（r[c[k]]=[…r[c[k]]||[]，c]，r），{}）；常量组By=（arr，k，fn=（）=>真）=>arr.reduce（（r，c）=>（fn（c[k]）？r[c[k]]=[…r[c[k]]| |[]，c]：null，r），{}）；console.log（group（data，'id'））//通过`reduce分组`console.log（groupBy（data，'id'））//如果省略了“fn”，则结果相同console.log（groupBy（data，'score'，x=>x>2））//使用iteratee分组

关于OP问题：

const data＝〔｛阶段：“阶段1”，步骤：“步骤1”，任务：“任务1”，值：“5”｝，｛阶段“阶段1“，步骤：”步骤1“，任务：”任务2“，值：”10“｝，{阶段：”阶段1“、步骤：”阶段2“，任务1“，值“15”｝、｛阶段”阶段1”、步骤：“阶段2”、任务：”“任务2”、值：”20“｝、{阶段“2”，步骤“步骤：”“步骤1“、任务：“1”、值“25”｝，｛阶段：“阶段2”，步骤：“步骤1”，任务：“任务2”，值：“30”｝，｛阶段：“阶段2”，步骤：“步骤2”，任务：“任务1”，值：”35“｝，{阶段：”阶段2“，步骤：”步骤2“，任务：”任务2“，值：：”40“｝]常量组By=（arr，k）=>arr.reduce（（r，c）=>（r[c[k]]=[…r[c[k]]||[]，c]，r），{}）；常量组With=（arr，k，fn=（）=>真）=>arr.reduce（（r，c）=>（fn（c[k]）？r[c[k]]=[…r[c[k]]| |[]，c]：null，r），{}）；console.log（groupBy（数据，'Phase'））console.log（groupWith（data，'Value'，x=>x>30））//按`Value`>30分组

另一个ES6版本，它反转分组，将值用作键，将键用作分组值：

常量数据=[｛A:“1”｝，｛B:“10”｝、｛C:“10”}]常量组键=arr=>arr.reduce（（r，c）=>（Object.keys（c）.map（x=>r[c[x]]=[…r[c[x]]||[]，x]），r），{}）；console.log（groupKeys（数据））

注意：函数以简短的形式（一行）发布，目的是为了简洁，并仅表达想法。您可以展开它们并添加其他错误检查等。