发帖是因为即使这个问题已经7年了，我仍然没有看到一个符合原始标准的答案：

我不希望它们“拆分”，而是“合并”，更像SQL组方法

我最初发表这篇文章是因为我想找到一种方法来减少对象数组（例如，当您从csv中读取时创建的数据结构），并通过给定索引聚合以生成相同的数据结构。我正在寻找的返回值是另一个对象数组，而不是我在这里看到的嵌套对象或映射。

下面的函数获取一个数据集（对象数组）、一个索引列表（数组）和一个reducer函数，并将reducer功能应用于索引的结果作为一个对象数组返回。

function agg(data, indices, reducer) {

  // helper to create unique index as an array
  function getUniqueIndexHash(row, indices) {
    return indices.reduce((acc, curr) => acc + row[curr], "");
  }

  // reduce data to single object, whose values will be each of the new rows
  // structure is an object whose values are arrays
  // [{}] -> {{}}
  // no operation performed, simply grouping
  let groupedObj = data.reduce((acc, curr) => {
    let currIndex = getUniqueIndexHash(curr, indices);

    // if key does not exist, create array with current row
    if (!Object.keys(acc).includes(currIndex)) {
      acc = {...acc, [currIndex]: [curr]}
    // otherwise, extend the array at currIndex
    } else {
      acc = {...acc, [currIndex]: acc[currIndex].concat(curr)};
    }

    return acc;
  }, {})

  // reduce the array into a single object by applying the reducer
  let reduced = Object.values(groupedObj).map(arr => {
    // for each sub-array, reduce into single object using the reducer function
    let reduceValues = arr.reduce(reducer, {});

    // reducer returns simply the aggregates - add in the indices here
    // each of the objects in "arr" has the same indices, so we take the first
    let indexObj = indices.reduce((acc, curr) => {
      acc = {...acc, [curr]: arr[0][curr]};
      return acc;
    }, {});

    reduceValues = {...indexObj, ...reduceValues};


    return reduceValues;
  });


  return reduced;
}

我将创建一个返回count（*）和sum（Value）的reducer：

reducer = (acc, curr) => {
  acc.count = 1 + (acc.count || 0);
  acc.value = +curr.Value + (acc.value|| 0);
  return acc;
}

最后，使用我们的reducer将agg函数应用于原始数据集会生成一个应用了适当聚合的对象数组：

agg(tasks, ["Phase"], reducer);
// yields:
Array(2) [
  0: Object {Phase: "Phase 1", count: 4, value: 50}
  1: Object {Phase: "Phase 2", count: 4, value: 130}
]

agg(tasks, ["Phase", "Step"], reducer);
// yields:
Array(4) [
  0: Object {Phase: "Phase 1", Step: "Step 1", count: 2, value: 15}
  1: Object {Phase: "Phase 1", Step: "Step 2", count: 2, value: 35}
  2: Object {Phase: "Phase 2", Step: "Step 1", count: 2, value: 55}
  3: Object {Phase: "Phase 2", Step: "Step 2", count: 2, value: 75}
]

如果您需要通过以下方式进行多组：

    const populate = (entireObj, keys, item) => {
    let keysClone = [...keys],
        currentKey = keysClone.shift();

    if (keysClone.length > 0) {
        entireObj[item[currentKey]] = entireObj[item[currentKey]] || {}
        populate(entireObj[item[currentKey]], keysClone, item);
    } else {
        (entireObj[item[currentKey]] = entireObj[item[currentKey]] || []).push(item);
    }
}

export const groupBy = (list, key) => {
    return list.reduce(function (rv, x) {

        if (typeof key === 'string') (rv[x[key]] = rv[x[key]] || []).push(x);

        if (typeof key === 'object' && key.length) populate(rv, key, x);

        return rv;

    }, {});
}

const myPets = [
    {name: 'yaya', type: 'cat', color: 'gray'},
    {name: 'bingbang', type: 'cat', color: 'sliver'},
    {name: 'junior-bingbang', type: 'cat', color: 'sliver'},
    {name: 'jindou', type: 'cat', color: 'golden'},
    {name: 'dahuzi', type: 'dog', color: 'brown'},
];

// run 
groupBy(myPets, ['type', 'color']));

// you will get object like: 

const afterGroupBy = {
    "cat": {
        "gray": [
            {
                "name": "yaya",
                "type": "cat",
                "color": "gray"
            }
        ],
        "sliver": [
            {
                "name": "bingbang",
                "type": "cat",
                "color": "sliver"
            },
            {
                "name": "junior-bingbang",
                "type": "cat",
                "color": "sliver"
            }
        ],
        "golden": [
            {
                "name": "jindou",
                "type": "cat",
                "color": "golden"
            }
        ]
    },
    "dog": {
        "brown": [
            {
                "name": "dahuzi",
                "type": "dog",
                "color": "brown"
            }
        ]
    }
};

使用ES6的简单解决方案：

该方法有一个返回模型，可以比较n个财产。

const compareKey = (item, key, compareItem) => {
    return item[key] === compareItem[key]
}

const handleCountingRelatedItems = (listItems, modelCallback, compareKeyCallback) => {
    return listItems.reduce((previousValue, currentValue) => {
        if (Array.isArray(previousValue)) {
        const foundIndex = previousValue.findIndex(item => compareKeyCallback(item, currentValue))

        if (foundIndex > -1) {
            const count = previousValue[foundIndex].count + 1

            previousValue[foundIndex] = modelCallback(currentValue, count)

            return previousValue
        }

        return [...previousValue, modelCallback(currentValue, 1)]
        }

        if (compareKeyCallback(previousValue, currentValue)) {
        return [modelCallback(currentValue, 2)]
        }

        return [modelCallback(previousValue, 1), modelCallback(currentValue, 1)]
    })
}

const itemList = [
    { type: 'production', human_readable: 'Production' },
    { type: 'test', human_readable: 'Testing' },
    { type: 'production', human_readable: 'Production' }
]

const model = (currentParam, count) => ({
    label: currentParam.human_readable,
    type: currentParam.type,
    count
})

const compareParameter = (item, compareValue) => {
    const isTypeEqual = compareKey(item, 'type', compareValue)
    return isTypeEqual
}

const result = handleCountingRelatedItems(itemList, model, compareParameter)

 console.log('Result: \n', result)
/** Result: 
    [
        { label: 'Production', type: 'production', count: 2 },
        { label: 'Testing', type: 'testing', count: 1 }
    ]
*/

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

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

您可以从array.reduce（）构建ES6映射。

const groupedMap = initialArray.reduce(
    (entryMap, e) => entryMap.set(e.id, [...entryMap.get(e.id)||[], e]),
    new Map()
);

这与其他解决方案相比有一些优势：

它不需要任何库（与例如_.groupBy（）不同）您得到的是JavaScript Map而不是对象（例如，由_.groupBy（）返回）。这有很多好处，包括：它会记住第一次添加项目的顺序，键可以是任何类型，而不仅仅是字符串。Map是比数组数组更有用的结果。但是，如果确实需要数组数组，则可以调用array.from（groupedMap.entries（））（对于[key，group array]对的数组）或array.from（groupedMap.values（）），（对于简单的数组数组）。它非常灵活；通常情况下，您计划使用此地图进行的任何操作都可以作为缩减的一部分直接完成。

作为最后一点的示例，假设我有一个对象数组，我想按id对其进行（浅）合并，如下所示：

const objsToMerge = [{id: 1, name: "Steve"}, {id: 2, name: "Alice"}, {id: 1, age: 20}];
// The following variable should be created automatically
const mergedArray = [{id: 1, name: "Steve", age: 20}, {id: 2, name: "Alice"}]

要做到这一点，我通常首先按id分组，然后合并每个结果数组。相反，您可以直接在reduce（）中执行合并：

const mergedArray = Array.from(
    objsToMerge.reduce(
        (entryMap, e) => entryMap.set(e.id, {...entryMap.get(e.id)||{}, ...e}),
        new Map()
    ).values()
);

稍后编辑：

对于大多数目的来说，上述方法可能足够有效。但最初的问题是“最有效”的，正如一些人所指出的，上述解决方案并非如此。问题主要是为每个条目实例化一个新数组。我本以为JS解释器会优化这一点，但似乎并非如此。

有人建议进行编辑来解决这个问题，但看起来确实更复杂。原始代码段已经有点提高了可读性。如果你真的想这样做，请使用for循环！这不是罪！它需要一到两行代码，但它比函数技术更简单，尽管它并不短：

groupedMap = new Map();
for (const e of initialArray) {
    if (groupedMap.has(e.id)) {
        groupedMap.get(e.id).push(e)
    }
    else {
        groupedMap.set(e.id, [e])
    }
}

在Joseph Nields的回答之后，有一个polyfill用于将对象分组https://github.com/padcom/array-prototype-functions#arrayprototypegroupbyfieldormapper.因此，您可能希望使用现有的内容，而不是一次又一次地编写这些内容。