Javascript 从阵列中删除重复的对象，但同时增加数量

我有以下清单：

const list=[
{名称：'AA'，数量：1}，
{名称：'AA'，数量：1}，
{名称：'BB'，数量：1}，
{name:'CC'，数量：1}，
{名称：'CC'，数量：2}，
]

我想要的输出应该是：

const newlist=[
{名称：'AA'，数量：2}，
{名称：'BB'，数量：1}，
{名称：'CC'，数量：3}，
]

这段代码删除了重复项，但我就是想不出当存在重复项时如何增加数量

const setObj=new Set（）
常量结果=列表减少（（acc，项目）=>{
如果（！setObj.has（item.name））{
setObj.add（item.name）
acc.push（{name:item.name，quantity:item.quantity}）
}
//for（列表的常量迭代器）{
//if（setObj.has（item.name））{
//log（“这里最明显的解决方案是使用对象，因为这就是您要构建的：一个具有唯一命名键的对象

const list = [
  { name: 'AA', quantity: 1 },
  { name: 'AA', quantity: 1 },
  { name: 'BB', quantity: 1 },
  { name: 'CC', quantity: 1 },
  { name: 'CC', quantity: 2 },
];

const filtered = list.reduce((tally, e) => {
  if (!tally[e.name]) tally[e.name] = 0;
  tally[e.name] += e.quantity
  return tally;
}, {});


这里最明显的解决方案是使用对象，因为这就是您要构建的：一个具有唯一命名键的对象

const list = [
  { name: 'AA', quantity: 1 },
  { name: 'AA', quantity: 1 },
  { name: 'BB', quantity: 1 },
  { name: 'CC', quantity: 1 },
  { name: 'CC', quantity: 2 },
];

const filtered = list.reduce((tally, e) => {
  if (!tally[e.name]) tally[e.name] = 0;
  tally[e.name] += e.quantity
  return tally;
}, {});


您可以循环创建新条目或增加当前条目：

let newList = [];
list.forEach((e)=>{
   let el=newList.find(n => n.name==e.name);
   if (el) el.quantity+=e.quantity;
   else newList.push(e);
});

您可以循环创建新条目或增加当前条目：

let newList = [];
list.forEach((e)=>{
   let el=newList.find(n => n.name==e.name);
   if (el) el.quantity+=e.quantity;
   else newList.push(e);
});

使用object.values（）返回结果数组的对象方法稍有不同


const list=[
{名称：'AA'，数量：1}，
{名称：'AA'，数量：1}，
{名称：'BB'，数量：1}，
{name:'CC'，数量：1}，
{名称：'CC'，数量：2}，
]
常量组={}；
list.forEach（e=>{
常量o=组[e.name]=组[e.name]|{…e，数量：0}
o、 数量+=e.数量
})
const res=对象值（组）
console.log（res）
与使用object.values（）返回结果数组的对象方法略有不同


const list=[
{名称：'AA'，数量：1}，
{名称：'AA'，数量：1}，
{名称：'BB'，数量：1}，
{name:'CC'，数量：1}，
{名称：'CC'，数量：2}，
]
常量组={}；
list.forEach（e=>{
常量o=组[e.name]=组[e.name]|{…e，数量：0}
o、 数量+=e.数量
})
const res=对象值（组）
console.log（res）
您可以使用
reduce
然后在结果数组中查找元素，如果它不存在
则将
推到
数组中
，否则
将
当前元素
数量添加到
结果
数组中找到的
元素

代码：


const list=[{name:“AA”，数量：1}，{name:“AA”，数量：1}，{name:“BB”，数量：1}，{name:“CC”，数量：1}，{name:“CC”，数量：2}]；
const res=列表减少（（acc，e）=>{
const found=acc.find（x=>e.name==x.name）
找到？找到数量+=e数量：根据推送（e）
返回acc
}, [])
console.log（res）
.as控制台包装{最大高度：100%！重要；顶部：0；}
您可以使用
减少
然后在结果数组中查找元素，如果它不存在
则将
推送到
数组
，否则
将
当前元素
数量
添加到结果
数组
中找到的
元素

代码：


const list=[{name:“AA”，数量：1}，{name:“AA”，数量：1}，{name:“BB”，数量：1}，{name:“CC”，数量：1}，{name:“CC”，数量：2}]；
const res=列表减少（（acc，e）=>{
const found=acc.find（x=>e.name==x.name）
找到？找到数量+=e数量：根据推送（e）
返回acc
}, [])
console.log（res）
.as console wrapper{max height:100%！important；top:0；}
我很确定我想要的是对象数组，而不是具有唯一键的对象，但这是close，它本质上是一个对象。entries（）但是你也可以做另一个答案中提到的forEach迭代。我很确定我想得到的是对象数组，而不是具有唯一键的对象，但这很接近，它本质上是一个对象。entries（）离开，但你也可以做另一个答案中提到的forEach迭代。不要使用
map
来产生副作用。
map
返回一个转换后的数组。使用它，或者使用
forEach
。是的，谢谢你这是我需要的，除此之外，我还将使用forEach感谢你这一点。我已经修复了它。为什么要使用find（）同一数组元素两次？因为更容易键入：P。我已经修复了它。对于副作用，不要使用
map
。
map
返回一个已转换的数组。使用它，或者使用
forEach
。是的，谢谢这是我需要的，除此之外，我还将使用每个感谢点。我已经修复了它。为什么使用find（）对同一数组元素执行两次？因为更容易键入：P。我已经修复了它。当您推送对象时，请执行
quantity:item.quantity*list.filter（I=>I.name==item.name）。length
。尝试了，但得到了{name:'AA'，quantity:2}，{name:'BB quantity:1}，{name:'CC'，quantity:2}cc应该是3Ah，对吧，因为
quantity
不一定总是1。是的，你必须求和，在这一点上，你最好减少整个事情的
reduce
。当你推对象时，做
quantity:item.quantity*list.filter（i=>i.name==item.name.length
。尝试过了，但得到了{name:'AA'，数量：2}，{name:'BB'，数量：1}，{name:'CC'，数量：2}cc应该是3Ah，对吧，因为数量不一定总是1。是的，你必须求和，在这一点上，你最好减少整个事情。我会给出这个最好的答案，因为我注意到其他的数量在使用多次后也会增加。我会给出这个这是一个最好的答案，因为我注意到，在多次使用之后，其他产品的数量也会增加。