为了补充Scott Sauyet的答案，一些人在评论中询问如何使用他的函数按值1、值2等分组，而不是仅对一个值分组。

只需编辑他的求和函数：

DataGrouper.register("sum", function(item) {
    return _.extend({}, item.key,
        {VALUE1: _.reduce(item.vals, function(memo, node) {
        return memo + Number(node.VALUE1);}, 0)},
        {VALUE2: _.reduce(item.vals, function(memo, node) {
        return memo + Number(node.VALUE2);}, 0)}
    );
});

保持主组（DataGrouper）不变：

var DataGrouper = (function() {
    var has = function(obj, target) {
        return _.any(obj, function(value) {
            return _.isEqual(value, target);
        });
    };

    var keys = function(data, names) {
        return _.reduce(data, function(memo, item) {
            var key = _.pick(item, names);
            if (!has(memo, key)) {
                memo.push(key);
            }
            return memo;
        }, []);
    };

    var group = function(data, names) {
        var stems = keys(data, names);
        return _.map(stems, function(stem) {
            return {
                key: stem,
                vals:_.map(_.where(data, stem), function(item) {
                    return _.omit(item, names);
                })
            };
        });
    };

    group.register = function(name, converter) {
        return group[name] = function(data, names) {
            return _.map(group(data, names), converter);
        };
    };

    return group;
}());

如果希望避免使用外部库，可以简洁地实现groupBy（）的普通版本，如下所示：

var groupBy=函数（xs，key）{返回xs.reduce（函数（rv，x）{（rv[x[key]]=rv[x[键]]| |[]）.push（x）；返回rv；}, {});};console.log（groupBy（['one'，'two'，'three']，'length'））；//=>｛“3”：[“1”，“2”]，“5”：[”3“]｝

我不认为给出的答案是对问题的回应，我认为以下内容应回答第一部分：

常量arr=[｛阶段：“阶段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”｝]const groupBy=（key）=>arr.sort（（a，b）=>a[key].localeCompare（b[key]））.reduce（（total，currentValue）=>{const newTotal=总计；如果(总长度&&总计[total.length-1][key]==当前值[key])新总计[total.length-1]={…总计[总长度-1]，…当前值，值：parseInt（total[total.length-1].Value）+parseInt（currentValue.Value，};else newTotal[total.length]=当前值；return newTotal；}, []);console.log（groupBy（“阶段”））；//=>[｛阶段：“阶段1”，值：50｝，｛阶段“阶段2”，值130｝]console.log（groupBy（“步骤”））；//=>[｛步骤：“步骤1”，值：70｝，｛步骤“步骤2”，值为110｝]

我会检查一下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

var arr = [ 
    { Phase: "Phase 1", `enter code here`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" }
];

创建并清空对象。循环遍历arr并添加使用Phase作为obj的唯一键。在循环遍历arr时，保持更新obj中的键总数。

const obj = {};
arr.forEach((item) => {
  obj[item.Phase] = obj[item.Phase] ? obj[item.Phase] + 
  parseInt(item.Value) : parseInt(item.Value);
});

结果如下：

{ "Phase 1": 50, "Phase 2": 130 }

循环通过obj形成表单和resultArr。

const resultArr = [];
for (item in obj) {
  resultArr.push({ Phase: item, Value: obj[item] });
}
console.log(resultArr);

基于以前的答案

const groupBy = (prop) => (xs) =>
  xs.reduce((rv, x) =>
    Object.assign(rv, {[x[prop]]: [...(rv[x[prop]] || []), x]}), {});

如果您的环境支持，使用对象扩展语法会更好一些。

const groupBy = (prop) => (xs) =>
  xs.reduce((acc, x) => ({
    ...acc,
    [ x[ prop ] ]: [...( acc[ x[ prop ] ] || []), x],
  }), {});

在这里，我们的reducer接受部分形成的返回值（从一个空对象开始），并返回一个由上一个返回值的展开成员组成的对象，以及一个新成员，该成员的键是从prop处的当前iteree值计算的，其值是该prop的所有值以及当前值的列表。