按数组中的对象分组最有效的方法是什么？
例如，给定此对象数组：
[
{ 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" }
]
我正在表格中显示这些信息。我想通过不同的方法进行分组，但我想对值求和。
我将Undercore.js用于其groupby函数，这很有用，但并不能完成全部任务，因为我不希望它们“拆分”，而是“合并”，更像SQL groupby方法。
我要找的是能够合计特定值（如果需要）。
因此，如果我按阶段分组，我希望收到：
[
{ Phase: "Phase 1", Value: 50 },
{ Phase: "Phase 2", Value: 130 }
]
如果我组了阶段/步骤，我会收到：
[
{ 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 }
]
是否有一个有用的脚本，或者我应该坚持使用Undercore.js，然后遍历生成的对象，自己计算总数？
这里有一个使用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[]>);
为了补充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;
}());
