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

常量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｝]

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

常量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｝]

使用ES6 Map对象：

/***@描述*采用Array＜V＞和分组函数，*并返回由分组函数分组的数组的Map。**@param list V类型的数组。*@param keyGetter一个函数，将数组类型V作为输入，并返回类型K的值。*K通常是V的属性键。**@返回由分组函数分组的数组的映射。*///导出函数组By＜K，V＞（列表：Array＜V＞，keyGetter：（输入：V）=>K）：Map＜K，Array＜V>>{//const-map=new map<K，Array<V>>（）；函数groupBy（list，keyGetter）{const-map=new map（）；list.forEach（（项）=>{const key=keyGetter（项）；constcollection=map.get（key）；if（！集合）{map.set（键，[项]）；}其他{collection.push（项）；}});回归图；}//示例用法常量宠物=[｛type:“Dog”，name:“Spot”｝，{类型：“猫”，名称：“老虎”}，{类型：“狗”，名称：“路虎”}，｛类型：“猫”，名称：“利奥”｝];const grouped=groupBy（宠物，宠物=>宠物类型）；console.log（分组.get（“Dog”））；//->〔｛类型：“狗”，名称：“斑点”｝，｛类型“狗”、名称：“漫游者”｝〕console.log（分组.get（“Cat”））；//->〔｛类型：“猫”，名称：“老虎”｝，｛类型“猫”、名称：“狮子座”｝〕const奇数=符号（）；const even=符号（）；常量=[1,2,3,4,5,6,7]；const oddEven=groupBy（数字，x=>（x%2===1？奇数：偶数））；console.log（oddEven.get（奇数））；//->[1,3,5,7]console.log（oddEven.get（偶数））；//->[2,4,6]

关于地图：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map

GroupBy one liner，ES2021解决方案

const groupBy = (x,f)=>x.reduce((a,b,i)=>((a[f(b,i,x)]||=[]).push(b),a),{});

TypeScript（类型脚本）

const groupBy = <T>(array: T[], predicate: (value: T, index: number, array: T[]) => string) =>
  array.reduce((acc, value, index, array) => {
    (acc[predicate(value, index, array)] ||= []).push(value);
    return acc;
  }, {} as { [key: string]: T[] });

示例

const groupBy = (x,f)=>x.reduce((a,b,i)=>((a[f(b,i,x)]||=[]).push(b),a),{});
// f -> should must return string/number because it will be use as key in object

// for demo

groupBy([1, 2, 3, 4, 5, 6, 7, 8, 9], v => (v % 2 ? "odd" : "even"));
// { odd: [1, 3, 5, 7, 9], even: [2, 4, 6, 8] };
const colors = [
  "Apricot",
  "Brown",
  "Burgundy",
  "Cerulean",
  "Peach",
  "Pear",
  "Red",
];

groupBy(colors, v => v[0]); // group by colors name first letter
// {
//   A: ["Apricot"],
//   B: ["Brown", "Burgundy"],
//   C: ["Cerulean"],
//   P: ["Peach", "Pear"],
//   R: ["Red"],
// };
groupBy(colors, v => v.length); // group by length of color names
// {
//   3: ["Red"],
//   4: ["Pear"],
//   5: ["Brown", "Peach"],
//   7: ["Apricot"],
//   8: ["Burgundy", "Cerulean"],
// }

const data = [
  { comment: "abc", forItem: 1, inModule: 1 },
  { comment: "pqr", forItem: 1, inModule: 1 },
  { comment: "klm", forItem: 1, inModule: 2 },
  { comment: "xyz", forItem: 1, inModule: 2 },
];

groupBy(data, v => v.inModule); // group by module
// {
//   1: [
//     { comment: "abc", forItem: 1, inModule: 1 },
//     { comment: "pqr", forItem: 1, inModule: 1 },
//   ],
//   2: [
//     { comment: "klm", forItem: 1, inModule: 2 },
//     { comment: "xyz", forItem: 1, inModule: 2 },
//   ],
// }

groupBy(data, x => x.forItem + "-" + x.inModule); // group by module with item
// {
//   "1-1": [
//     { comment: "abc", forItem: 1, inModule: 1 },
//     { comment: "pqr", forItem: 1, inModule: 1 },
//   ],
//   "1-2": [
//     { comment: "klm", forItem: 1, inModule: 2 },
//     { comment: "xyz", forItem: 1, inModule: 2 },
//   ],
// }

按映射分组

const groupByToMap = (x, f) =>
  x.reduce((a, b, i, x) => {
    const k = f(b, i, x);
    a.get(k)?.push(b) ?? a.set(k, [b]);
    return a;
  }, new Map());

TypeScript（类型脚本）

const groupByToMap = <T, Q>(array: T[], predicate: (value: T, index: number, array: T[]) => Q) =>
  array.reduce((map, value, index, array) => {
    const key = predicate(value, index, array);
    map.get(key)?.push(value) ?? map.set(key, [value]);
    return map;
  }, new Map<Q, T[]>());

groupByArray(xs, key) {
    return xs.reduce(function (rv, x) {
        let v = key instanceof Function ? key(x) : x[key];
        let el = rv.find((r) => r && r.key === v);
        if (el) {
            el.values.push(x);
        }
        else {
            rv.push({
                key: v,
                values: [x]
            });
        }
        return rv;
    }, []);
}

这一个输出数组。

通常，我使用Lodash JavaScript实用程序库和预先构建的groupBy（）方法。它非常容易使用，请在此处查看更多详细信息。