我想建议一下我的方法。首先，分开分组和聚合。让我们声明原型“groupby”函数。它需要另一个函数为要分组的每个数组元素生成“哈希”字符串。

Array.prototype.groupBy = function(hash){
  var _hash = hash ? hash : function(o){return o;};

  var _map = {};
  var put = function(map, key, value){
    if (!map[_hash(key)]) {
        map[_hash(key)] = {};
        map[_hash(key)].group = [];
        map[_hash(key)].key = key;

    }
    map[_hash(key)].group.push(value); 
  }

  this.map(function(obj){
    put(_map, obj, obj);
  });

  return Object.keys(_map).map(function(key){
    return {key: _map[key].key, group: _map[key].group};
  });
}

分组完成后，您可以根据需要聚合数据

data.groupBy(function(o){return JSON.stringify({a: o.Phase, b: o.Step});})
    /* aggreagating */
    .map(function(el){ 
         var sum = el.group.reduce(
           function(l,c){
             return l + parseInt(c.Value);
           },
           0
         );
         el.key.Value = sum; 
         return el.key;
    });

一般来说，它是有效的。我已经在chrome控制台中测试了这段代码。并随时改进和发现错误；）

此解决方案采用任意函数（而不是键），因此比上述解决方案更灵活，并允许箭头函数，这与LINQ中使用的lambda表达式类似：

Array.prototype.groupBy = function (funcProp) {
    return this.reduce(function (acc, val) {
        (acc[funcProp(val)] = acc[funcProp(val)] || []).push(val);
        return acc;
    }, {});
};

注意：是否要扩展Array的原型取决于您。

大多数浏览器支持的示例：

[{a:1,b:"b"},{a:1,c:"c"},{a:2,d:"d"}].groupBy(function(c){return c.a;})

使用箭头函数（ES6）的示例：

[{a:1,b:"b"},{a:1,c:"c"},{a:2,d:"d"}].groupBy(c=>c.a)

以上两个示例都返回：

{
  "1": [{"a": 1, "b": "b"}, {"a": 1, "c": "c"}],
  "2": [{"a": 2, "d": "d"}]
}

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

这里是一个由一些字段组成的对象数组的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））；

/***数组分组依据*@类别数组*@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>

您可以使用Alasql JavaScript库来实现：

var data = [ { Phase: "Phase 1", Step: "Step 1", Task: "Task 1", Value: "5" },
             { Phase: "Phase 1", Step: "Step 1", Task: "Task 2", Value: "10" }];

var res = alasql('SELECT Phase, Step, SUM(CAST([Value] AS INT)) AS [Value] \
                  FROM ? GROUP BY Phase, Step',[data]);

在jsFiddle尝试这个示例。

BTW：在大型阵列（100000条记录及以上）上，Alasql比Linq更快。参见jsPref中的测试。

评论：

这里我将Value放在方括号中，因为Value是SQL中的关键字我必须使用CAST（）函数将字符串值转换为数字类型。

您可以使用本机JavaScript组数组方法（目前处于第3阶段）。

我认为，与reduce相比，或者与lodash等第三方库相比，解决方案要优雅得多。

常量产品=[{名称：“牛奶”，类型：“乳制品”},{名称：“cheese”，类型：“乳制品”},{名称：“牛肉”，类型：“肉”},{名称：“chicken”，类型：“肉”}];const productsByType=products.group（（product）=>product.type）；console.log（“按类型分组的产品：”，productsByType）；<script src=“https://cdn.jsdelivr.net/npm/core-js-bundle@3.23.2/minified.min.js“></script>