Reduce函数在集合上迭代

arr = [{x:1},{x:2},{x:4}] // is a collection

arr.reduce(function(a,b){return a.x + b.x})

翻译:

arr.reduce(
    //for each index in the collection, this callback function is called
  function (
    a, //a = accumulator ,during each callback , value of accumulator is 
         passed inside the variable "a"
    b, //currentValue , for ex currentValue is {x:1} in 1st callback
    currentIndex,
    array
  ) {
    return a.x + b.x; 
  },
  accumulator // this is returned at the end of arr.reduce call 
    //accumulator = returned value i.e return a.x + b.x  in each callback. 
);

在每次索引回调期间，变量accumulator的值为 在回调函数中传入"a"参数。如果不初始化"accumulator"，它的值将是undefined。调用定义。X会给出误差。 要解决这个问题，初始化“accumulator”，值为0，如Casey的答案所示。

为了理解“reduce”函数的输入输出，我建议您查看该函数的源代码。 Lodash库有reduce函数，它的工作原理与ES6中的“reduce”函数完全相同。

以下是链接: 减少源代码

Reduce函数在集合上迭代

arr = [{x:1},{x:2},{x:4}] // is a collection

arr.reduce(function(a,b){return a.x + b.x})

翻译:

arr.reduce(
    //for each index in the collection, this callback function is called
  function (
    a, //a = accumulator ,during each callback , value of accumulator is 
         passed inside the variable "a"
    b, //currentValue , for ex currentValue is {x:1} in 1st callback
    currentIndex,
    array
  ) {
    return a.x + b.x; 
  },
  accumulator // this is returned at the end of arr.reduce call 
    //accumulator = returned value i.e return a.x + b.x  in each callback. 
);

在每次索引回调期间，变量accumulator的值为 在回调函数中传入"a"参数。如果不初始化"accumulator"，它的值将是undefined。调用定义。X会给出误差。 要解决这个问题，初始化“accumulator”，值为0，如Casey的答案所示。

为了理解“reduce”函数的输入输出，我建议您查看该函数的源代码。 Lodash库有reduce函数，它的工作原理与ES6中的“reduce”函数完全相同。

以下是链接: 减少源代码

其他人已经回答了这个问题，但我认为我应该提出另一种方法。你可以结合一个映射(从a.x到x)和reduce(把x相加)，而不是直接对a.x求和:

arr = [{x:1},{x:2},{x:4}]
arr.map(function(a) {return a.x;})
   .reduce(function(a,b) {return a + b;});

不可否认，它可能会稍微慢一些，但我认为值得把它作为一个选项提出来。

泛型typescript函数:

const sum = <T>(array: T[], predicate: (value: T, index: number, array: T[]) => number) => {
      return array.reduce((acc, value, index, array) => {
        return acc + predicate(value, index, array);
      }, 0);
    };

例子:

const s = sum(arr, (e) => e.x);

我曾经遇到过这种情况，我所做的是将我的解决方案包装在一个函数中，使其在我的环境中可重用，就像这样:

const sumArrayOfObject =(array, prop)=>array.reduce((sum, n)=>{return sum + n[prop]}, 0)

一个更简洁的方法是提供一个初始值作为reduce的第二个参数:

Var arr = [{x:1}， {x:2}， {x:4}]; Var结果= arr。Reduce(函数(acc, obj){返回acc + obj.x;}, 0); console.log(结果);/ / 7

第一次调用匿名函数时，使用(0，{x: 1})调用它，并返回0 + 1 = 1。下一次，它被(1，{x: 2})调用，并返回1 + 2 = 3。然后用(3，{x: 4})调用它，最后返回7。

这也可以处理数组为空的情况，返回0。