Javascript 将对象数组中的所有数据相加到新的对象数组中

我有一个如下所示的对象数组：

var数据=[
{机票价格：2500，酒店价格：1200}，
{机票价格：1500，酒店价格：1000}，
]

我想对数组中的每个元素求和，得到如下数组：

var result=[{costOfAirtickets:4000，costOfHotel:2200}]

我使用了map和reduce函数，但我只能对单个元素求和，如下所示：

data.map（item=>item.costOfAirtickets）。减少（（上一个，下一个）=>prev+next）；//22

目前，这产生了一个单一的价值，这不是我想要的根据初步解释

---

有没有办法用Javascript或lodash实现这一点。

您可以使用一个简单的

forEach（）

循环：

var data=[{costOfAirtickets:2500，costOfHotel:1200}，{costOfAirtickets:1500，costOfHotel:1000}]；
var-res=[]；
var tempObj={}；
data.forEach（{costOfAirtickets，costOfHotel}）=>{
tempObj['costOfAirtickets']=（tempObj['costOfAirtickets']| | 0）+costOfAirtickets；
tempObj['costOfHotel']=（tempObj['costOfHotel']| | 0）+costOfHotel；
});
res.push（tempObj）；
控制台日志（res）尝试使用reduce，如下代码片段所示。尝试避免多次迭代。希望下面的代码片段能有所帮助


var data=[{costOfAirtickets:2500，costOfHotel:1200}，{costOfAirtickets:1500，costOfHotel:1000}]
var total=data.reduce（函数（结果、值、键）{
结果['costOfAirtickets']=结果['costOfAirtickets']+值['costOfAirtickets']；
结果['costOfHotel']=结果['costOfHotel']+价值['costOfHotel']；
返回结果}，{costOfAirtickets:0，costOfHotel:0}）；
log（总计）
您可以通过获取一个对象进行求和来减少数组


var data=[{costOfAirtickets:2500，costOfHotel:1200}，{costOfAirtickets:1500，costOfHotel:1000}]，
keys=['costOfAirtickets'，'costOfHotel']，
总和=数据。减少（（r，o）=>{
forEach（k=>r[k]+=o[k]）；
返回r；
}，Object.assign（…keys.map（k=>（{[k]：0}））；
控制台日志（总和）
要创建结果值/缩减值，应使用
.reduce（）
方法，而不是
.map（）
：


let数据=[
{机票价格：2500，酒店价格：1200}，
{机票价格：1500，酒店价格：1000}
];
让结果=data.reduce(
（a，c）=>（Object.keys（c）.forEach（k=>（a[k]=（a[k]| | 0）+c[k]），a），{}
);
控制台日志（结果）使用
for..in
迭代对象，并
减少
迭代数组


var data=[{costOfAirtickets:2500，costOfHotel:1200}，{costOfAirtickets:1500，costOfHotel:1000}]；
var结果=[数据减少（（acc，n）=>{
for（n中的var prop）{
如果（acc.hasOwnProperty（prop））acc[prop]+=n[prop]；
else acc[prop]=n[prop]；
}
返回acc；
}, {})]
log（result）
您不需要映射数组，实际上只是减少了数组中的内容

const totalCostOfAirTickets: data.reduce((prev, next) => prev + next.costOfAirTickets, 0)
const totalCostOfHotel: data.reduce((prev, next) => prev + next.costOfHotel, 0)
const totals = [{totalCostOfAirTickets, totalCostOfHotel}]

在一次尝试中，你可以做如下事情

const totals = data.reduce((prev, next) => { 
    prev.costOfAirTickets += next.costOfAirTickets; 
    prev.costOfHotel += next.costOfHotel; 
}, {costOfAirTickets: 0, costOfHotel: 0})

映射对象，计算总和并将其存储在另一个对象中


var data=[{costOfAirtickets:2500，costOfHotel:1200}，{costOfAirtickets:1500，costOfHotel:1000}]；
var结果=[]；
var总和=0；
var-costsum=0；
数据映射（功能（项、键）{
var成本=项目；
//解决方案日志（成本）；
总和=总和+成本。机票成本；
成本总额=成本总额+成本。酒店成本；
});
结果=[{costOfAirtickets:sum，costOfHotel:costsum}]；
控制台日志（结果）使用Lodash简化您的生活

const _ = require('lodash')
let keys = ['costOfAirtickets', 'costOfHotel']; 
let results = _.zipObject(keys, keys.map(key => _.sum( _.map(data, key))))
...
{ costOfAirtickets: 4000, costOfHotel: 2200 }

说明：


\uu.sum（\uu.map（数据，键））
：生成每个数组的总和
\uuu.zipObject
：使用数组和对结果进行压缩
使用
keys.map（）
作为每个键的总和
。.map
不能保证顺序

文件：


总数：
zipObject：
地图：
这里有一个
lodash
方法

_(data).flatMap(_.entries).groupBy(0).mapValues(v=>_.sumBy(v, 1)).value()

它将按所有唯一键求和


var data=[{costOfAirtickets:2500，costOfHotel:1200}，{costOfAirtickets:1500，costOfHotel:1000}]；
var res=u0（数据）.flatMap（0.entries）.groupBy（0）.mapValues（v=>0.sumBy（v，0））.value（）；
控制台日志（res）

var data=[{costOfAirtickets:2500，costOfHotel:1200}，{costOfAirtickets:1500，costOfHotel:1000}]；
var结果=[数据减少（（acc，n）=>{
for（n中的var prop）{
如果（acc[prop]）acc[prop]+=n[prop]；
else acc[prop]=n[prop]；
}
返回acc；
}, {})]
console.log（result）
另一种解决方案是使用
Map
（而不是Array.prototype.Map），因为它有几个：


var数据=[{
机票费用：2500，
酒店费用：1200
}, {
机票价格：1500，
酒店成本：1000
}]
让总和=数据。减少（（收集，rcd）=>{
Object.entries（rcd.forEach）（[key，value]）=>{
设sum=collection.get（key）| 0
集合集合（键，总和++值）
})
回收
}，新映射（））
console.log（…sums.entries（））
这是我能想到的最简单的方法

var data = [{costOfAirtickets: 2500, costOfHotel: 1200},{costOfAirtickets: 1500, costOfHotel: 1000}];
var sum ={};
for(var obj in data){
  for(var ele in data[obj]){
    if(!data[obj].hasOwnProperty(ele)) continue;
      if(sum[ele] === undefined){
        sum[ele] = data[obj][ele];
      }else{
        sum[ele] = sum[ele] + data[obj][ele];
      }
  }

}
var arr = [sum];
console.log(arr);

我过于简单的回答是：


var data=[{costOfAirtickets:2500，costOfHotel:1200}，
{机票价格：1500，酒店价格：1000}]，
res=data.reduce（（p，c）=>Object.entries（c）.reduce（（r[k，v]）=>（r[k]+=v，r，p））；
控制台日志（res）洛达斯

使用
lodash
，这是一个单行程序：


var data=[{costOfAirtickets:2500，costOfHotel:1200}，{costOfAirtickets:1500，costOfHotel:1000}]
var result=\.reduce（数据，（r，c）=>\.mergeWith（r，c，（o=0，s）=>o+s），{}）
console.log（结果）
为什么要返回数组？因为我想在角度视图中循环数组。但是你不需要任何循环来处理单个对象。你的意思是对象数组。
酒店的成本应该是
2200
我猜为什么简单属性的括号