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

常量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'
    }
  ]
}

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;
}, {})

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

我已经改进了答案。此函数获取组字段数组并返回分组对象，该对象的键也是组字段的对象。

function(xs, groupFields) {
        groupFields = [].concat(groupFields);
        return xs.reduce(function(rv, x) {
            let groupKey = groupFields.reduce((keyObject, field) => {
                keyObject[field] = x[field];
                return keyObject;
            }, {});
            (rv[JSON.stringify(groupKey)] = rv[JSON.stringify(groupKey)] || []).push(x);
            return rv;
        }, {});
    }



let x = [
{
    "id":1,
    "multimedia":false,
    "language":["tr"]
},
{
    "id":2,
    "multimedia":false,
    "language":["fr"]
},
{
    "id":3,
    "multimedia":true,
    "language":["tr"]
},
{
    "id":4,
    "multimedia":false,
    "language":[]
},
{
    "id":5,
    "multimedia":false,
    "language":["tr"]
},
{
    "id":6,
    "multimedia":false,
    "language":["tr"]
},
{
    "id":7,
    "multimedia":false,
    "language":["tr","fr"]
}
]

groupBy(x, ['multimedia','language'])

//{
//{"multimedia":false,"language":["tr"]}: Array(3), 
//{"multimedia":false,"language":["fr"]}: Array(1), 
//{"multimedia":true,"language":["tr"]}: Array(1), 
//{"multimedia":false,"language":[]}: Array(1), 
//{"multimedia":false,"language":["tr","fr"]}: Array(1)
//}

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);