使用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();

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

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

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

具有排序功能

export const groupBy = function groupByArray(xs, key, sortKey) {
      return xs.reduce(function(rv, x) {
        let v = key instanceof Function ? key(x) : x[key];
        let el = rv.find(r => r && r.key === v);

        if (el) {
          el.values.push(x);
          el.values.sort(function(a, b) {
            return a[sortKey].toLowerCase().localeCompare(b[sortKey].toLowerCase());
          });
        } else {
          rv.push({ key: v, values: [x] });
        }

        return rv;
      }, []);
    };

示例：

var state = [
    {
      name: "Arkansas",
      population: "2.978M",
      flag:
  "https://upload.wikimedia.org/wikipedia/commons/9/9d/Flag_of_Arkansas.svg",
      category: "city"
    },{
      name: "Crkansas",
      population: "2.978M",
      flag:
        "https://upload.wikimedia.org/wikipedia/commons/9/9d/Flag_of_Arkansas.svg",
      category: "city"
    },
    {
      name: "Balifornia",
      population: "39.14M",
      flag:
        "https://upload.wikimedia.org/wikipedia/commons/0/01/Flag_of_California.svg",
      category: "city"
    },
    {
      name: "Florida",
      population: "20.27M",
      flag:
        "https://upload.wikimedia.org/wikipedia/commons/f/f7/Flag_of_Florida.svg",
      category: "airport"
    },
    {
      name: "Texas",
      population: "27.47M",
      flag:
        "https://upload.wikimedia.org/wikipedia/commons/f/f7/Flag_of_Texas.svg",
      category: "landmark"
    }
  ];
console.log(JSON.stringify(groupBy(state,'category','name')));

我会检查声明性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());

从@mortb、@jmarceli的回答和这篇文章中，

我利用JSON.stringify（）作为分组依据的PRIMITIVE VALUE多列的标识。

无第三方

function groupBy(list, keyGetter) {
    const map = new Map();
    list.forEach((item) => {
        const key = keyGetter(item);
        if (!map.has(key)) {
            map.set(key, [item]);
        } else {
            map.get(key).push(item);
        }
    });
    return map;
}

const pets = [
    {type:"Dog", age: 3, name:"Spot"},
    {type:"Cat", age: 3, name:"Tiger"},
    {type:"Dog", age: 4, name:"Rover"}, 
    {type:"Cat", age: 3, name:"Leo"}
];

const grouped = groupBy(pets,
pet => JSON.stringify({ type: pet.type, age: pet.age }));

console.log(grouped);

使用Lodash第三方

const pets = [
    {type:"Dog", age: 3, name:"Spot"},
    {type:"Cat", age: 3, name:"Tiger"},
    {type:"Dog", age: 4, name:"Rover"}, 
    {type:"Cat", age: 3, name:"Leo"}
];

let rslt = _.groupBy(pets, pet => JSON.stringify(
 { type: pet.type, age: pet.age }));

console.log(rslt);