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

此解决方案采用任意函数（而不是键），因此比上述解决方案更灵活，并允许箭头函数，这与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"}]
}

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（数据））

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

let groupbyKeys = function(arr, ...keys) {
  let keysFieldName = keys.join();
  return arr.map(ele => {
    let keysField = {};
    keysField[keysFieldName] = keys.reduce((keyValue, key) => {
      return keyValue + ele[key]
    }, "");
    return Object.assign({}, ele, keysField);
  }).reduce((groups, ele) => {
    (groups[ele[keysFieldName]] = groups[ele[keysFieldName]] || [])
      .push([ele].map(e => {
        if (keys.length > 1) {
          delete e[keysFieldName];
        }
        return e;
    })[0]);
    return groups;
  }, {});
};

console.log(groupbyKeys(array, 'Phase'));
console.log(groupbyKeys(array, 'Phase', 'Step'));
console.log(groupbyKeys(array, 'Phase', 'Step', 'Task'));

我会检查一下lodash组，它似乎正是你想要的。它也很轻，非常简单。

Fiddle示例：https://jsfiddle.net/r7szvt5k/

如果数组名称为arr，则带有lodash的groupBy仅为：

import groupBy from 'lodash/groupBy';
// if you still use require:
// const groupBy = require('lodash/groupBy');

const a = groupBy(arr, function(n) {
  return n.Phase;
});
// a is your array grouped by Phase attribute

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