Javascript 如何按第一个元素对象键对数组中的数组进行分组

得到了如下数组：

    let arr = [
      [
        {"key":2, "other":123},
        {"key":2, "other":222}
      ],
      [
        {"key":3, "other":0}
      ],
      [
        {"key":1, "other":11},
        {"key":1, "other":23}
      ],
      [
        {"key":1, "other":22}
      ]
    ]

我需要得到这个

arr

，但是分组数组与第一个元素的“key”值相同，所以它看起来像：

  let arr = [
      [
        {"key":2, "other":123},
        {"key":2, "other":222}
      ],
      [
        {"key":3, "other":0}
      ],
      [
        [
          {"key":1, "other":11},
          {"key":1, "other":23}
        ],
        [
          {"key":1, "other":22}
        ]
      ],

    ]

我尝试使用reduce函数，但结果完全不同

let final = []
  for (let i=0; i<arr.length; i++) {

    let arr1 = i==0?arr:arr.slice(i)

    let final1 = arr1.reduce((acc,x)=> {

      acc = acc[0].key==x[0].key?acc.concat(x):acc
      return acc
    })
    arr1.length>1&&final.push(final1)
  }

let final=[]
for（设i=0；i{
acc=acc[0]。键==x[0]。键？acc.concat（x）：acc
返回acc
})
arr1.长度>1和最终推送（final1）
}

---

在这段代码中，问题是它将arr[1]与arr[2]进行比较，arr[3]，然后再将arr[2]与arr[3]进行比较并将其分组（即使arr[1]。key和arr[2]。key和arr[3]。key是相同的），您能给出一些提示或给出完成此操作的最终函数吗？

我想得到类似的结果，请尝试运行该代码段

让arr=[
[
{
“关键”：2
},
{
“关键”：2
}
],
[
{
“关键”：3
}
],
[
{
“关键”：1
},
{
“关键”：1
}
],
[
{
“关键”：1
}
]
]
让结果=arr.reduce（（res，数组）=>{
array.forEach（（值，索引）=>{
const obj=res.find（a=>{
return！！a.find（{key}）=>{
返回键===value.key
})
})
如果（obj）{
目标推力（值）
}否则{
res.push（[值]）
}
})
返回res；
}, [])
控制台日志（结果）

创建

键的对象及其计数。然后，您可以过滤出现多次的密钥，即：e
（count>=2）
。然后使用
reduce
迭代输入数组，查看它是否存在于过滤后的数组键中，如果是，则推入单独的数组，另一个是
accu
。然后将两个数组合并为一个数组


让输入=[
[
{“key”：2，“other”：123}，
{“键”：2，“其他”：222}
],
[
{“键”：3，“其他”：0}
],
[
{“键”：1，“其他”：11}，
{“键”：1，“其他”：23}
],
[
{“键”：1，“其他”：22}
]
];
//具有唯一键及其计数的键。计数大于2的筛选器。
const groupByArrKeysOccurrence=输入。减少（（累计，arr）=>{
const key=arr[0]。key；
累计[键]=（累计[键]| | 0）+1；
返回accu；
}, {});
const filteredKeys=Object.entries（groupbyarrkeyoccurrence）.filter（[[u，val]）=>val>1.map（[key，[u]）=>Number（key））；
常量multiplearrancekeys=[]；
const singlearoccurrencekeys=输入。减少（（累计，累计）=>{
const isKey=arr.some（（{key}）=>filteredKeys.includes（key））；
如果（isKey）{
多个按键。按（arr）；
}否则{
累计推力（arr）；
}
返回accu；
}, []);
log（[…singlearoccurrencekeys，multiplearoccurrencekeys]）此解决方案不会产生您想要的确切结果，但它很好且干净。您想要的结果很可能会在将来给您带来一些麻烦，因为有些元素比其他元素嵌套得更远

这个答案假设每个数组总是至少有一个元素，因为问题是按第一个元素键分组


让arr=[[{“键”：2，“其他”：123}，{“键”：2，“其他”：222}]，{“键”：3，“其他”：0}]，{“键”：1，“其他”：11}，{“键”：1，“其他”：23}]，{“键”：1，“其他”：22}]；
设群={}；
让group=key=>groups[key]| |（groups[key]=[]）；
arr.forEach（arr=>group（arr[0].key）.push（arr））；
控制台日志（组）；
日志（对象值（组））；
//如果你想得到你想要的结果（而不是看
//顺序），您可以简单地展平1个元素的所有组。虽然
//根据您的使用情况，我建议您坚持以上内容。
console.log（Object.values（groups.map）（group=>group.length==1？group[0]：group））
让arr=[
[
{“键”：2}，
{“键”：2}
],
[
{“键”：3}
],
[
{“键”：1}，
{“键”：1}
],
[
{“键”：1}
]
]
var myMap=newmap（）；
对于（i=0；i

您将在out数组中找到您的响应。希望它对你有用
你为什么选择这种结构？它背后的用例是什么？这听起来像是一个XY问题。2个对象具有相同键值的数组被分组为数组：[数组，数组]这是一个奇怪的数据集，我无法预见这种结构的任何优势，无论是性能还是可读性。是的，我看到了。但是为什么呢？为什么不
[{key:1，count:2}，…]
？我从API获得JSON响应，我需要将其分组以块的形式显示。初始数组的结构是第一级分组的结果，任务是第二个任务，以便像我所需要的那样在div中列出它们，这确实适用于示例，但是如果我们将输入数组的第一个数组从[{“key”：2，“other”：123}，{“key”：2，“other”：222}]修改为[{“key”：3，“other”：123}，{“key”：3，“other”：222}]，最终数组长度应为2，第一个数组的键为3，第二个数组的键为1
let arr = [
      [
        {"key":2},
        {"key":2}
      ],
      [
        {"key":3}
      ],
      [
        {"key":1},
        {"key":1}
      ],
      [
        {"key":1}
      ]
    ]
var myMap = new Map();
for (i = 0; i < arr.length; i++) { 
    if(!myMap.has(arr[i][0]['key'])){
        myMap.set(arr[i][0]['key'],i)
    }else if(myMap.get(arr[i][0]['key'])===undefined){

        myMap.set(arr[i][0]['key'],i)
    }else{
        myMap.set(arr[i][0]['key'],myMap.get(arr[i][0]['key'])+','+i)
    }
}
var out =[];
for(var v of myMap.values()){
    var s = String(v).split(",");
    var fi = s[0]
    var subarray =[]
    for(var i in s){
        subarray.push(arr[s[i]]) 
    }
    out[fi] = subarray;
}