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

虽然linq的回答很有趣，但它也很重。我的方法有些不同：

var DataGrouper = (function() {
    var has = function(obj, target) {
        return _.any(obj, function(value) {
            return _.isEqual(value, target);
        });
    };

    var keys = function(data, names) {
        return _.reduce(data, function(memo, item) {
            var key = _.pick(item, names);
            if (!has(memo, key)) {
                memo.push(key);
            }
            return memo;
        }, []);
    };

    var group = function(data, names) {
        var stems = keys(data, names);
        return _.map(stems, function(stem) {
            return {
                key: stem,
                vals:_.map(_.where(data, stem), function(item) {
                    return _.omit(item, names);
                })
            };
        });
    };

    group.register = function(name, converter) {
        return group[name] = function(data, names) {
            return _.map(group(data, names), converter);
        };
    };

    return group;
}());

DataGrouper.register("sum", function(item) {
    return _.extend({}, item.key, {Value: _.reduce(item.vals, function(memo, node) {
        return memo + Number(node.Value);
    }, 0)});
});

您可以在JSBin上看到它的作用。

我在Undercore中没有看到任何东西可以做已经做的事情，尽管我可能会错过它。它与_.incontains非常相似，但使用_.isEqual而不是==进行比较。除此之外，其余部分都是针对具体问题的，尽管只是试图通用。

现在DataGrouper.sum（data，[“Phase”]）返回

[
    {Phase: "Phase 1", Value: 50},
    {Phase: "Phase 2", Value: 130}
]

DataGrouper.sum（data，[“Phase”，“Step”]）返回

[
    {Phase: "Phase 1", Step: "Step 1", Value: 15},
    {Phase: "Phase 1", Step: "Step 2", Value: 35},
    {Phase: "Phase 2", Step: "Step 1", Value: 55},
    {Phase: "Phase 2", Step: "Step 2", Value: 75}
]

但和在这里只是一个势函数。您可以根据需要注册其他人：

DataGrouper.register("max", function(item) {
    return _.extend({}, item.key, {Max: _.reduce(item.vals, function(memo, node) {
        return Math.max(memo, Number(node.Value));
    }, Number.NEGATIVE_INFINITY)});
});

现在DataGrouper.max（data，[“Phase”，“Step”]）将返回

[
    {Phase: "Phase 1", Step: "Step 1", Max: 10},
    {Phase: "Phase 1", Step: "Step 2", Max: 20},
    {Phase: "Phase 2", Step: "Step 1", Max: 30},
    {Phase: "Phase 2", Step: "Step 2", Max: 40}
]

或者如果您注册了：

DataGrouper.register("tasks", function(item) {
    return _.extend({}, item.key, {Tasks: _.map(item.vals, function(item) {
      return item.Task + " (" + item.Value + ")";
    }).join(", ")});
});

然后调用DataGrouper.tasks（data，[“Phase”，“Step”]）将得到

[
    {Phase: "Phase 1", Step: "Step 1", Tasks: "Task 1 (5), Task 2 (10)"},
    {Phase: "Phase 1", Step: "Step 2", Tasks: "Task 1 (15), Task 2 (20)"},
    {Phase: "Phase 2", Step: "Step 1", Tasks: "Task 1 (25), Task 2 (30)"},
    {Phase: "Phase 2", Step: "Step 2", Tasks: "Task 1 (35), Task 2 (40)"}
]

DataGrouper本身是一个函数。可以用数据和要分组的财产列表来调用它。它返回一个数组，该数组的元素是具有两个财产的对象：key是分组财产的集合，vals是包含不在key中的其余财产的对象数组。例如，DataGrouper（data，[“Phase”，“Step”]）将产生：

[
    {
        "key": {Phase: "Phase 1", Step: "Step 1"},
        "vals": [
            {Task: "Task 1", Value: "5"},
            {Task: "Task 2", Value: "10"}
        ]
    },
    {
        "key": {Phase: "Phase 1", Step: "Step 2"},
        "vals": [
            {Task: "Task 1", Value: "15"}, 
            {Task: "Task 2", Value: "20"}
        ]
    },
    {
        "key": {Phase: "Phase 2", Step: "Step 1"},
        "vals": [
            {Task: "Task 1", Value: "25"},
            {Task: "Task 2", Value: "30"}
        ]
    },
    {
        "key": {Phase: "Phase 2", Step: "Step 2"},
        "vals": [
            {Task: "Task 1", Value: "35"}, 
            {Task: "Task 2", Value: "40"}
        ]
    }
]

DataGrouper.register接受一个函数并创建一个新函数，该函数接受初始数据和分组依据的财产。然后，这个新函数采用上述输出格式，并依次对每个输出格式运行函数，返回一个新数组。生成的函数根据您提供的名称存储为DataGrouper的属性，如果您只需要本地引用，也会返回。

这是很多解释。我希望代码相当简单！

让我们生成一个通用的Array.protocol.groupBy（）工具。为了多样化，让我们在递归方法上使用ES6 fancyty扩展运算符进行Haskell式模式匹配。同样，让我们让Array.prototype.groupBy（）接受一个回调，该回调将项（e）、索引（i）和应用的数组（a）作为参数。

Array.prototype.groupBy=函数（cb）{返回函数迭代（[x，…xs]，i=0，r=[[]，[]]）{cb（x，i，[x，…xs]）？（r[0].推（x），r）：（r[1].推（x），r）；是否返回xs.length？迭代（xs，++i，r）：r；}（本）；};var arr=[0,1,2,3,4,5,6,7,8,9]，res=arr.groupBy（e=>e<5）；console.log（res）；

Array.prototype.groupBy = function(keyFunction) {
    var groups = {};
    this.forEach(function(el) {
        var key = keyFunction(el);
        if (key in groups == false) {
            groups[key] = [];
        }
        groups[key].push(el);
    });
    return Object.keys(groups).map(function(key) {
        return {
            key: key,
            values: groups[key]
        };
    });
};

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

这里是一个由一些字段组成的对象数组的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））；

我想建议一下我的方法。首先，分开分组和聚合。让我们声明原型“groupby”函数。它需要另一个函数为要分组的每个数组元素生成“哈希”字符串。

Array.prototype.groupBy = function(hash){
  var _hash = hash ? hash : function(o){return o;};

  var _map = {};
  var put = function(map, key, value){
    if (!map[_hash(key)]) {
        map[_hash(key)] = {};
        map[_hash(key)].group = [];
        map[_hash(key)].key = key;

    }
    map[_hash(key)].group.push(value); 
  }

  this.map(function(obj){
    put(_map, obj, obj);
  });

  return Object.keys(_map).map(function(key){
    return {key: _map[key].key, group: _map[key].group};
  });
}

分组完成后，您可以根据需要聚合数据

data.groupBy(function(o){return JSON.stringify({a: o.Phase, b: o.Step});})
    /* aggreagating */
    .map(function(el){ 
         var sum = el.group.reduce(
           function(l,c){
             return l + parseInt(c.Value);
           },
           0
         );
         el.key.Value = sum; 
         return el.key;
    });

一般来说，它是有效的。我已经在chrome控制台中测试了这段代码。并随时改进和发现错误；）