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

MDN的Array.reduce（）文档中有此示例。

// Grouping objects by a property
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce#Grouping_objects_by_a_property#Grouping_objects_by_a_property

var people = [
  { name: 'Alice', age: 21 },
  { name: 'Max', age: 20 },
  { name: 'Jane', age: 20 }
];

function groupBy(objectArray, property) {
  return objectArray.reduce(function (acc, obj) {
    var key = obj[property];
    if (!acc[key]) {
      acc[key] = [];
    }
    acc[key].push(obj);
    return acc;
  }, {});
}

var groupedPeople = groupBy(people, 'age');
// groupedPeople is:
// { 
//   20: [
//     { name: 'Max', age: 20 }, 
//     { name: 'Jane', age: 20 }
//   ], 
//   21: [{ name: 'Alice', age: 21 }] 
// }

此解决方案采用任意函数（而不是键），因此比上述解决方案更灵活，并允许箭头函数，这与LINQ中使用的lambda表达式类似：

Array.prototype.groupBy = function (funcProp) {
    return this.reduce(function (acc, val) {
        (acc[funcProp(val)] = acc[funcProp(val)] || []).push(val);
        return acc;
    }, {});
};

注意：是否要扩展Array的原型取决于您。

大多数浏览器支持的示例：

[{a:1,b:"b"},{a:1,c:"c"},{a:2,d:"d"}].groupBy(function(c){return c.a;})

使用箭头函数（ES6）的示例：

[{a:1,b:"b"},{a:1,c:"c"},{a:2,d:"d"}].groupBy(c=>c.a)

以上两个示例都返回：

{
  "1": [{"a": 1, "b": "b"}, {"a": 1, "c": "c"}],
  "2": [{"a": 2, "d": "d"}]
}

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[]>());

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

常量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基于reduce的版本，支持iteratee函数。

如果未提供iteratee函数，则工作正常：

const data＝〔｛id:1，得分：2｝，｛id:1，得分：3｝，{id:2，得分：2}，｛id：2，得分：4｝〕常量组=（arr，k）=>arr.reduce（（r，c）=>（r[c[k]]=[…r[c[k]]||[]，c]，r），{}）；常量组By=（arr，k，fn=（）=>真）=>arr.reduce（（r，c）=>（fn（c[k]）？r[c[k]]=[…r[c[k]]| |[]，c]：null，r），{}）；console.log（group（data，'id'））//通过`reduce分组`console.log（groupBy（data，'id'））//如果省略了“fn”，则结果相同console.log（groupBy（data，'score'，x=>x>2））//使用iteratee分组

关于OP问题：

const data＝〔｛阶段：“阶段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“｝]常量组By=（arr，k）=>arr.reduce（（r，c）=>（r[c[k]]=[…r[c[k]]||[]，c]，r），{}）；常量组With=（arr，k，fn=（）=>真）=>arr.reduce（（r，c）=>（fn（c[k]）？r[c[k]]=[…r[c[k]]| |[]，c]：null，r），{}）；console.log（groupBy（数据，'Phase'））console.log（groupWith（data，'Value'，x=>x>30））//按`Value`>30分组

另一个ES6版本，它反转分组，将值用作键，将键用作分组值：

常量数据=[｛A:“1”｝，｛B:“10”｝、｛C:“10”}]常量组键=arr=>arr.reduce（（r，c）=>（Object.keys（c）.map（x=>r[c[x]]=[…r[c[x]]||[]，x]），r），{}）；console.log（groupKeys（数据））

注意：函数以简短的形式（一行）发布，目的是为了简洁，并仅表达想法。您可以展开它们并添加其他错误检查等。