Javascript 如何按对象的值对对象数组进行分组，并在新属性中对结果求和

我有一个像这样的对象数组

const orders = [{
    "oreder": "Order/1",
    "itemCount": 2    
  }, {
    "oreder": "Order/2",
    "itemCount": 1
  }, {
    "oreder": "Order/3",
    "itemCount": 3
  }, {
    "oreder": "Order/4",
    "itemCount": 2
  }, {
    "oreder": "Order/5",
    "itemCount": 2
  }, {
    "oreder": "Order/6",
    "itemCount": 1
 }];

我试图实现的是通过

itemCount

对对象进行分组，并为每个对象添加一个新属性，该属性的名称为

numberOfOrders

，值为相同的

itemCount

属性之和。这是我想要的一个例子

const orders = [{
    "itemCount": 1,
    "numberOfOrders": 2,
  }, {
    "itemCount": 2,
    "numberOfOrders": 3,
  }, {
    "itemCount": 3,
    "numberOfOrders": 1,
 }];

我试图通过使用reduce来实现这一点

const result = orders.reduce(function (r, a) {
   r[a.itemCount] = r[a.itemCount] || [];
   r[a.itemCount].push(a);
   return r;
}, Object.create(null));

console.log(result);

---

但这不是我想要的。我该怎么做？任何例子都将不胜感激

您需要计数，而不是在数组中收集项目。最后，从对象获取值

const
orders=[{order:“order/1”，itemCount:2}，{order:“order/2”，itemCount:1}，{order:“order/3”，itemCount:3}，{order:“order/4”，itemCount:2}，{order:“order/5”，itemCount:2}，{order:“order/6”，itemCount:1}]，
result=Object.values（orders.reduce）（函数（r，{itemCount}）{
r[itemCount]=r[itemCount]|{itemCount，numberOfOrders:0}；
r[itemCount].numberOfOrders++；
返回r；
}，Object.create（null））；
控制台日志（结果）
.as console wrapper{max height:100%！important；top:0；}
您需要计数，而不是收集数组中的项。最后，从对象获取值


const
orders=[{order:“order/1”，itemCount:2}，{order:“order/2”，itemCount:1}，{order:“order/3”，itemCount:3}，{order:“order/4”，itemCount:2}，{order:“order/5”，itemCount:2}，{order:“order/6”，itemCount:1}]，
result=Object.values（orders.reduce）（函数（r，{itemCount}）{
r[itemCount]=r[itemCount]|{itemCount，numberOfOrders:0}；
r[itemCount].numberOfOrders++；
返回r；
}，Object.create（null））；
控制台日志（结果）
.as console wrapper{max height:100%！important；top:0；}
您可以使用数组reduce方法来计算itemCount的频率。然后使用Object.keys获取所有的键，并使用数组映射方法创建一个新对象


const orders=[
{
Order:“订单/1”，
物品计数：2，
},
{
Order:“订单/2”，
物品计数：1，
},
{
Order:“订单/3”，
物品计数：3，
},
{
Order:“订单/4”，
物品计数：2，
},
{
Order:‘订单/5’，
物品计数：2，
},
{
Order:“订单/6”，
物品计数：1，
},
];
让ret=订单。减少（（上一个，c）=>{
常数p=上一个；
const key=c.itemCount；
如果（！p[key]）p[key]=1；
否则p[键]+=1；
返回p；
}, {});
ret=Object.keys（ret.map）（x）=>({
物品计数：x，
订单数量：ret[x]，
}));
控制台日志（ret）您可以使用数组减少方法来计算itemCount的频率。然后使用Object.keys获取所有的键，并使用数组映射方法创建一个新对象


const orders=[
{
Order:“订单/1”，
物品计数：2，
},
{
Order:“订单/2”，
物品计数：1，
},
{
Order:“订单/3”，
物品计数：3，
},
{
Order:“订单/4”，
物品计数：2，
},
{
Order:‘订单/5’，
物品计数：2，
},
{
Order:“订单/6”，
物品计数：1，
},
];
让ret=订单。减少（（上一个，c）=>{
常数p=上一个；
const key=c.itemCount；
如果（！p[key]）p[key]=1；
否则p[键]+=1；
返回p；
}, {});
ret=Object.keys（ret.map）（x）=>({
物品计数：x，
订单数量：ret[x]，
}));
控制台日志（ret）
这种方法非常好，但是如果对象键是string，我想知道如何实现同样的效果。F.e.“itemCount”你有通缉犯的例子吗？（对象的键是字符串，除非它是符号。）orders=[{“Transactions.orderId”：“Order/1”，“Transactions.itemCount”：“24”}，{“Transactions.orderId”：“Order/2”，“Transactions.itemCount”：“3”}]。。。。像这样的我明白了。。有希望地您可能需要一个不同的解构：
函数（r，{'Transactions.itemCount'：itemCount}{
，然后您需要一个结果集的属性。就是这样！太棒了！非常感谢！这种方法非常好，但是我想知道如果对象键是string.F.e.“itemCount”，您有想要的例子吗？（对象的键是字符串，除非它是一个符号。）orders=[{“Transactions.orderId”：“Order/1”，“Transactions.itemCount”：“24”}，{“Transactions.orderId”：“Order/2”，“Transactions.itemCount”：“3”}]……类似的内容我看到了……希望如此。您可能需要不同的解构：
函数（r，{“Transactions.itemCount”：itemCount}）{
然后您需要结果集的属性。就是这样！太棒了！非常感谢！