让我们在重用已经编写的代码（即Undercore）的同时充分回答最初的问题。如果将Undercore的>100个功能组合在一起，您可以使用Undercore做得更多。下面的解决方案演示了这一点。

步骤1：按财产的任意组合对数组中的对象进行分组。这使用了一个事实，即_.groupBy接受一个返回对象组的函数。它还使用了_.schain、_.pick、_.values、_.jjoin和_.value。请注意，这里并不严格需要_.value，因为链接的值在用作属性名称时会自动展开。我加入它是为了防止在没有自动展开的情况下有人试图编写类似的代码时发生混淆。

// Given an object, return a string naming the group it belongs to.
function category(obj) {
    return _.chain(obj).pick(propertyNames).values().join(' ').value();
}

// Perform the grouping.
const intermediate = _.groupBy(arrayOfObjects, category);

给定原始问题中的arrayOfObjects并将propertyNames设置为['Phase'，'Step']，intermediate将获得以下值：

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

步骤2：将每个组缩减为单个平面对象，并将结果返回到数组中。除了我们之前看到的函数之外，下面的代码使用了_.pulse、..first、..pick、..extend、..reduce和..map。.first保证在这种情况下返回一个对象，因为..groupBy不会产生空组。在这种情况下，值是必需的。

// Sum two numbers, even if they are contained in strings.
const addNumeric = (a, b) => +a + +b;

// Given a `group` of objects, return a flat object with their common
// properties and the sum of the property with name `aggregateProperty`.
function summarize(group) {
    const valuesToSum = _.pluck(group, aggregateProperty);
    return _.chain(group).first().pick(propertyNames).extend({
        [aggregateProperty]: _.reduce(valuesToSum, addNumeric)
    }).value();
}

// Get an array with all the computed aggregates.
const result = _.map(intermediate, summarize);

给定我们之前获得的中间值，并将aggregateProperty设置为Value，我们得到了询问者想要的结果：

[
    { Phase: "Phase 1", Step: "Step 1", Value: 15 },
    { Phase: "Phase 1", Step: "Step 2", Value: 35 },
    { Phase: "Phase 2", Step: "Step 1", Value: 55 },
    { Phase: "Phase 2", Step: "Step 2", Value: 75 }
]

我们可以将所有这些放在一个函数中，该函数将arrayOfObjects、propertyNames和aggregateProperty作为参数。请注意，arrayOfObjects实际上也可以是带有字符串键的普通对象，因为_.groupBy接受其中之一。为此，我将arrayOfObjects重命名为collection。

function aggregate(collection, propertyNames, aggregateProperty) {
    function category(obj) {
        return _.chain(obj).pick(propertyNames).values().join(' ');
    }
    const addNumeric = (a, b) => +a + +b;
    function summarize(group) {
        const valuesToSum = _.pluck(group, aggregateProperty);
        return _.chain(group).first().pick(propertyNames).extend({
            [aggregateProperty]: _.reduce(valuesToSum, addNumeric)
        }).value();
    }
    return _.chain(collection).groupBy(category).map(summarize).value();
}

aggregate（arrayOfObjects，['Phase'，'Step']，'Value'）现在将再次为我们提供相同的结果。

我们可以更进一步，使调用者能够计算每个组中值的任何统计信息。我们可以这样做，也可以让调用者向每个组的摘要添加任意财产。我们可以在缩短代码的同时完成所有这些。我们用iteratee参数替换aggregateProperty参数，并将其直接传递给_.reduce：

function aggregate(collection, propertyNames, iteratee) {
    function category(obj) {
        return _.chain(obj).pick(propertyNames).values().join(' ');
    }
    function summarize(group) {
        return _.chain(group).first().pick(propertyNames)
            .extend(_.reduce(group, iteratee)).value();
    }
    return _.chain(collection).groupBy(category).map(summarize).value();
}

实际上，我们将部分责任转移给了来电者；她必须提供一个可以传递给.reduce的iterate，这样对.reduce的调用将生成一个包含她想要添加的聚合财产的对象。例如，我们使用以下表达式获得与之前相同的结果：

aggregate(arrayOfObjects, ['Phase', 'Step'], (memo, value) => ({
    Value: +memo.Value + +value.Value
}));

对于一个稍微复杂一点的迭代的示例，假设我们希望计算每个组的最大值而不是总和，并且我们希望添加一个列出组中出现的Task的所有值的Tasks属性。这里有一种方法可以做到这一点，使用上面最后一个版本的聚合（和_.union）：

aggregate(arrayOfObjects, ['Phase', 'Step'], (memo, value) => ({
    Value: Math.max(memo.Value, value.Value),
    Tasks: _.union(memo.Tasks || [memo.Task], [value.Task])
}));

我们得到以下结果：

[
    { Phase: "Phase 1", Step: "Step 1", Value: 10, Tasks: [ "Task 1", "Task 2" ] },
    { Phase: "Phase 1", Step: "Step 2", Value: 20, Tasks: [ "Task 1", "Task 2" ] },
    { Phase: "Phase 2", Step: "Step 1", Value: 30, Tasks: [ "Task 1", "Task 2" ] },
    { Phase: "Phase 2", Step: "Step 2", Value: 40, Tasks: [ "Task 1", "Task 2" ] }
]

归功于@much2learn，他还发布了一个可以处理任意缩减函数的答案。我又写了几个SO答案，演示了如何通过组合多个Undercore函数来实现复杂的功能：

https://stackoverflow.com/a/64938636/1166087https://stackoverflow.com/a/64094738/1166087https://stackoverflow.com/a/63625129/1166087https://stackoverflow.com/a/63088916/1166087

想象一下，你有这样的东西：

〔｛id:1，cat:'sedan'｝，｛id:2，cat:'sport‘｝，{id:3，cat:'sport‘}，｛id:4，cat:'sadan‘｝〕

通过这样做：const categories=[…new Set（cars.map（（car）=>car.cat））]

你会得到这个：[“sadan”，“port”]

说明：1.首先，我们通过传递一个数组来创建一个新的Set。由于Set仅允许唯一值，因此将删除所有重复项。

现在重复项消失了，我们将使用扩展运算符将其转换回数组。。。

设置文档：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set排列运算符文档：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

这里有一个使用ES6的讨厌的、难以阅读的解决方案：

export default (arr, key) => 
  arr.reduce(
    (r, v, _, __, k = v[key]) => ((r[k] || (r[k] = [])).push(v), r),
    {}
  );

对于那些询问这是如何工作的人，这里有一个解释：

在这两个=>中，您可以获得免费回报Array.prototype.reduce函数最多包含4个参数。这就是为什么要添加第五个参数，这样我们就可以使用默认值在参数声明级别为组（k）创建一个廉价的变量声明。（是的，这是巫术）如果我们的当前组在上一次迭代中不存在，我们将创建一个新的空数组（（r[k]||（r[k]=[]））。这将计算到最左边的表达式，换句话说，一个现有数组或一个空数组，这就是为什么在该表达式之后会立即推送，因为无论哪种方式都会得到一个数组。当有一个返回时，逗号运算符将丢弃最左边的值，返回该场景中经过调整的前一组。

更容易理解的版本是：

export default (array, key) => 
  array.reduce((previous, currentItem) => {
    const group = currentItem[key];
    if (!previous[group]) previous[group] = [];
    previous[group].push(currentItem);
    return previous;
  }, {});

编辑：

TS版本：

const groupBy = <T, K extends keyof any>(list: T[], getKey: (item: T) => K) =>
  list.reduce((previous, currentItem) => {
    const group = getKey(currentItem);
    if (!previous[group]) previous[group] = [];
    previous[group].push(currentItem);
    return previous;
  }, {} as Record<K, T[]>);

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

在我的特定用例中，我需要按属性分组，然后删除分组属性。

无论如何，该属性只是为了分组目的而添加到记录中的，对于向用户显示它没有意义。

    group (arr, key) {

        let prop;

        return arr.reduce(function(rv, x) {
            prop = x[key];
            delete x[key];
            (rv[prop] = (rv[prop] || [])).push(x);
            return rv;
        }, {});

    },

顶部答案中的起始函数归功于@caesar bautista。

您可以使用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（）函数将字符串值转换为数字类型。