这里有一个ES6版本，不会在空成员上中断

function groupBy (arr, key) {
  return (arr || []).reduce((acc, x = {}) => ({
    ...acc,
    [x[key]]: [...acc[x[key]] || [], x]
  }), {})
}

data = [{id:1, name:'BMW'}, {id:2, name:'AN'}, {id:3, name:'BMW'}, {id:1, name:'NNN'}]
key = 'id'//try by id or name
data.reduce((previous, current)=>{
    previous[current[key]] && previous[current[key]].length != 0 ? previous[current[key]].push(current) : previous[current[key]] = new Array(current)
    return previous;
}, {})

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

一种新的方法，有一个用于分组的对象和另外两个用于创建键的函数，并获得一个包含所需分组项的对象和另一个用于添加值的键。

常量groupBy=（数组，组，valueKey）=>{常量getKey=o=>groups.map（k=>o[k]）.join（'|'），getObject=o=>Object.fromEntries（[…groups.map（k=>[k，o[k]]），[valueKey，0]）；groups=[].contat（组）；return Object.values（array.reduce（（r，o）=>{（r[getKey（o）]？？=getObject（o））[valueKey]+=+o[valueKey]；返回r；}, {}));},data=[｛阶段：“阶段1”，步骤：“步骤1”，任务：“任务1”，值：“5”｝，｛阶段“阶段1“，步骤：”步骤1“，任务：”任务2“，值：”10“｝，{阶段：”阶段1“、步骤：”第2“、任务：”第1“、值：”15“｝、｛阶段”阶段1”、步骤：“第2”、任务：“2”、值：“20”｝、{阶段“第2阶段”，步骤“步骤：”第一步“，任务“任务：”，值“25”｝阶段：“阶段2”，步骤：“步骤1”，任务：“任务2”，值：“30”｝，｛阶段：“阶段2”，步骤：“步骤2”，任务：“任务1”，值：”35“｝，{阶段：”阶段2“，步骤：”步骤2“，任务：”任务2“，值：：”40“｝]；console.log（groupBy（data，'Phase'，'Value'））；console.log（groupBy（数据，['Phase'，'Step']，'Value'））；.作为控制台包装｛最大高度：100%！重要；顶部：0；｝

旧方法：

虽然这个问题有一些答案，而且答案看起来有点过于复杂，但我建议使用香草Javascript进行分组，并使用嵌套的（如果需要）Map。

函数groupBy（数组，组，valueKey）{var map=新地图；groups=[].contat（组）；返回数组.reduce（（r，o）=>{groups.reduce（（m，k，i，{length}）=>{var子；如果（m.has（o[k]））返回m.get（o[k]）；如果（i+1==长度）{child=对象.assign（…groups.map（k=>（｛[k]：o[k]｝）），｛[valueKey]：0｝）；r.push（儿童）；}其他{child=新地图；}m.set（o[k]，子）；回归儿童；}，map）[valueKey]+=+o[valueKey]；返回r；}, [])};var data=[｛阶段：“阶段1”，步骤：“步骤1”，任务：“任务1”，值：“5”｝，｛阶段“阶段1“，步骤：”步骤1“，任务：”任务2“，值：”10“｝，{阶段：”阶段1“、步骤：”阶段2“，任务1“，值“15”｝、｛阶段”阶段1”、步骤：“阶段2”，任务2“、值：”20“｝、{阶段2“、步骤1”、任务1“、任务1”、值：“25”}，｛阶段：“阶段2”，步骤：“步骤1”，任务：“任务2”，值：“30”｝，｛阶段：“阶段2”，步骤：“步骤2”，任务：“任务1”，值：”35“｝，{阶段：”阶段2“，步骤：”步骤2“，任务：”任务2“，值：：”40“｝]；console.log（groupBy（data，'Phase'，'Value'））；console.log（groupBy（数据，['Phase'，'Step']，'Value'））；.作为控制台包装｛最大高度：100%！重要；顶部：0；｝

这是一个基于TS的功能，不是性能最好的，但很容易阅读和理解！

function groupBy<T>(array: T[], key: string): Record<string, T[]> {
const groupedObject = {}
for (const item of array) {
  const value = item[key]
    if (groupedObject[value] === undefined) {
  groupedObject[value] = []
  }
  groupedObject[value].push(item)
}
  return groupedObject
}

我们以->

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" },
];
console.log(groupBy(data, 'Step'))
{
'Step 1': [
    {
      Phase: 'Phase 1',
      Step: 'Step 1',
      Task: 'Task 1',
      Value: '5'
    },
    {
      Phase: 'Phase 1',
      Step: 'Step 1',
      Task: 'Task 2',
      Value: '10'
    }
  ],
  'Step 2': [
    {
      Phase: 'Phase 1',
      Step: 'Step 2',
      Task: 'Task 1',
      Value: '15'
    },
    {
      Phase: 'Phase 1',
      Step: 'Step 2',
      Task: 'Task 2',
      Value: '20'
    }
  ]
}

使用lodash库很简单

let temp = []
  _.map(yourCollectionData, (row) => {
    let index = _.findIndex(temp, { 'Phase': row.Phase })
    if (index > -1) {
      temp[index].Value += row.Value 
    } else {
      temp.push(row)
    }
  })