数组中对象的值求和

Sum values of objects in array

本文关键字：求和 对象 数组      更新时间：2023-09-26

我想创建一个包含多个对象的数组的总和。

下面是一个示例： var array = [{"adults":2,"children":3},{"adults":2,"children":1}];

如何将成人和儿童的总和返回到一个新变量中？

谢谢三.

使用 Array.prototype.reduce() ，reduce（） 方法对累加器和数组的每个值（从左到右）应用一个函数，以将其减少为单个值。 

var array = [{
  "adults": 2,
  "children": 3
}, {
  "adults": 2,
  "children": 1
}];
var val = array.reduce(function(previousValue, currentValue) {
  return {
    adults: previousValue.adults + currentValue.adults,
    children: previousValue.children + currentValue.children
  }
});
console.log(val);

 
var array = [{"adults":2,"children":3},{"adults":2,"children":1}];
var totalChild = array.reduce((accum,item) => accum + item.children, 0)
console.log(totalChild) //output 4

看到还没有人发布这个...这是一个不错的速记方法：

.reduce((acc, curr) => acc + curr.property, 0)

例：

arr = [{x:1, y:-1}, {x:2, y:-2}, {x:3, y:-3}];
x_sum = arr.reduce((acc, curr) => acc + curr.x, 0); // 6
y_sum = arr.reduce((acc, curr) => acc + curr.y, 0); // -6

您可以为此任务编写一个函数，该函数使数组迭代应添加该属性的值。

该函数的主要功能是 Array#reduce 方法和一个返回实际计数 calue 和实际属性值的属性。

function count(array, key) {
    return array.reduce(function (r, a) {
        return r + a[key];
    }, 0);
}
var array = [{ "adults": 2, "children": 3 }, { "adults": 2, "children": 2 }],
    adults = count(array, 'adults'),
    children = count(array, 'children');
document.write('Adults: ' + adults + '<br>');
document.write('Children: ' + children + '<br>');

var array = [{"adults":2,"children":3},{"adults":2,"children":1}];
var sumProps = prop => (sum, obj) => sum += obj[prop];
var adultsCount = array.reduce( sumProps('adults'));
var childrenCount = array.reduce( sumProps('children'));

要将每个本质的总和放入单独的变量中：

var array = [{"adults":2,"children":3},{"adults":2,"children":1}];
var adults_sum = 0, children_sum = 0;
array.forEach(function(obj){
    adults_sum += obj["adults"];
    children_sum += obj["children"];
});
console.log(adults_sum, children_sum); // 4 4

我们不是在为你编写代码，但我想你应该尝试：

var val = array.reduce(function (sum, tuple) {
    return { adults: sum.adults + tuple.adults,
             children: sum.children + tuple.children };
});

这是一个函数式编程中有趣的练习。假设您已经有一个用于简单数字数组的 sum 函数，您可以实现一个函数，该函数将在两个表达式中对对象数组的所有键的总数求和。不需要循环、硬编码的属性名称、匿名函数或if/else。我从我的回答中采用了以下代码 如何获取包含对象数组中所有项目总和的对象？:

var add = (a, b) => a + b;
var sum = _.partial(_.reduce, _, add, 0);
function sumByProperties(data) {
    var keys = _.chain(data)
    .map(_.keys).flatten().uniq().value();
    return _.chain(keys).zip(keys).object()
    .mapObject(_.property)
    .mapObject(_.partial(_.map, data))
    .mapObject(_.compose(sum, _.compact))
    .value();
}
console.log(sumByProperties([{
    apple: 1,
    banana: 4,
    fish: 2,
    melon: 3,
}, {
    apple: 3,
    banana: 2,
    fish: 5,
    melon: 1,
}]));
<script src="https://cdn.jsdelivr.net/npm/underscore@1.13.6/underscore-umd-min.js"></script>

虽然sumByProperties的实现并不简单，但弄清楚它是如何工作的将加深你对函数式编程的理解。这将使您能够非常简洁地编写一些内容，例如顶部sum的定义。

为方便读者，以下是指向本代码段中使用的每个 Underscore 函数的文档的链接（按计算顺序）：

_.partial _.reduce _.chain _.map _.keys _.flatten _.uniq _.value _.zip _.object _.mapObject _.property _.partial _.compose _.compact

也许它可以帮助你，这也不需要使用减少功能。 

var sumAdult=0;
var sumChildren=0;
var array = [{
  "adult": 2,
  "children": 3
}, {
  "adult": 2,
  "children": 1
}];
 function x(a,b){
   return a+b;
 }
for (y in array){  
  sumAdult=x(0, array[y].adult);
  console.log( "adult :" + sumAdult);
  sumChildren=x(0, array[y].children);
  console.log( "children :" + sumChildren);
}
相关文章：