我从underscore.js fiddler那里借用了这个方法

window.helpers=(function (){
    var lookupIterator = function(value) {
        if (value == null){
            return function(value) {
                return value;
            };
        }
        if (typeof value === 'function'){
                return value;
        }
        return function(obj) {
            return obj[value];
        };
    },
    each = function(obj, iterator, context) {
        var breaker = {};
        if (obj == null) return obj;
        if (Array.prototype.forEach && obj.forEach === Array.prototype.forEach) {
            obj.forEach(iterator, context);
        } else if (obj.length === +obj.length) {
            for (var i = 0, length = obj.length; i < length; i++) {
                if (iterator.call(context, obj[i], i, obj) === breaker) return;
            }
        } else {
            var keys = []
            for (var key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) keys.push(key)
            for (var i = 0, length = keys.length; i < length; i++) {
                if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
            }
        }
        return obj;
    },
    // An internal function used for aggregate "group by" operations.
    group = function(behavior) {
        return function(obj, iterator, context) {
            var result = {};
            iterator = lookupIterator(iterator);
            each(obj, function(value, index) {
                var key = iterator.call(context, value, index, obj);
                behavior(result, key, value);
            });
            return result;
        };
    };

    return {
      groupBy : group(function(result, key, value) {
        Object.prototype.hasOwnProperty.call(result, key) ? result[key].push(value) :              result[key] = [value];
        })
    };
})();

var arr=[{a:1,b:2},{a:1,b:3},{a:1,b:1},{a:1,b:2},{a:1,b:3}];
 console.dir(helpers.groupBy(arr,"b"));
 console.dir(helpers.groupBy(arr,function (el){
   return el.b>2;
 }));

您可以在数组上使用forEach并构造一组新的项。以下是如何使用FlowType注释实现这一点

// @flow

export class Group<T> {
  tag: number
  items: Array<T>

  constructor() {
    this.items = []
  }
}

const groupBy = (items: Array<T>, map: (T) => number) => {
  const groups = []

  let currentGroup = null

  items.forEach((item) => {
    const tag = map(item)

    if (currentGroup && currentGroup.tag === tag) {
      currentGroup.items.push(item)
    } else {
      const group = new Group<T>()
      group.tag = tag
      group.items.push(item)
      groups.push(group)

      currentGroup = group
    }
  })

  return groups
}

export default groupBy

玩笑测试可以是这样的

// @flow

import groupBy from './groupBy'

test('groupBy', () => {
  const items = [
    { name: 'January', month: 0 },
    { name: 'February', month: 1 },
    { name: 'February 2', month: 1 }
  ]

  const groups = groupBy(items, (item) => {
    return item.month
  })

  expect(groups.length).toBe(2)
  expect(groups[1].items[1].name).toBe('February 2')
})

正确答案——只是浅分组。理解减少是很好的。问题还提供了额外总计计算的问题。

这里是一个由一些字段组成的对象数组的REAL GROUP BY，该字段具有1）计算的键名称和2）通过提供所需键的列表来实现分组级联的完整解决方案并将其唯一值转换为根键，如SQL GROUP BY做

常量inputArray=[｛阶段：“阶段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”｝];var outObject=inputArray.reduce（函数（a，e）{//GROUP BY估计密钥（estKey）可能只是一个普通密钥//a——累加器结果对象//e——依次检查的元素，即在此位置测试的元素//可以计算新的分组名称，但必须基于实字段的实际值设estKey=（e['Phase']）；（a[estKey]？a[estKey]：（a[est Key]=null | |[]））.push（e）；返回a；}, {});console.log（outObject）；

使用estKey--您可以按多个字段分组，添加其他聚合、计算或其他处理。

您还可以递归地分组数据。例如，最初按阶段分组，然后按步骤字段分组等等脂肪休息数据。

常量输入数组=[｛阶段：“阶段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”｝];/***获取obj WITH属性的SHALLOW副本的小助手*/const rmProp=（obj，prop）=>（（｛[prop]：_，…rest｝）=>rest）（obj））/***按关键字分组数组。结果数组的根键是value*指定密钥的。**@param｛Array｝src源数组*@param｛String｝key分组依据的by key*@return｛Object｝将分组对象作为值的对象*/const grpBy=（src，key）=>src.reduce（（a，e）=>(（a[e[key]]=a[e[键]]| |[]）.push（rmProp（e，键）），a), {});/***如果对象数组仅由具有单个值的对象组成，则折叠该数组。*将其替换为剩余值。*/const blowObj=obj=>Array.isArray（obj）&&obj.length==1&&Object.values（obj[0]）.length==1？对象.值（obj[0]）[0]：obj；/***带有键列表的递归分组`keyList`可以是数组*或UNIQUE值将使用逗号分隔的键名列表*成为结果对象的关键点。*/const grpByReal=函数（src，keyList）{const[key，…rest]=Array.isArray（keyList）？keyList:String（keyList）.trim（）.split（/\s*，\s*/）；常量res=键？grpBy（src，key）：[…src]；if（剩余长度）{for（常量k，单位：res）{res[k]=grpByReal（res[k]，其余）}}其他{for（常量k，单位：res）{res[k]=blowObj（res[k]）}}回报率；}console.log（JSON.stringify（grpByReal（inputArray，'阶段，步骤，任务'），null，2））；

使用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

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（）方法。它非常容易使用，请在此处查看更多详细信息。