//fill创建包含n元素的数组 //reduce需要2个参数，第3个参数作为长度 var fibonacci = (n) =>数组(n).fill()。Reduce ((a, b, c) => { 返回a.concat(c < 2 ?C: a[C - 1] + a[C - 2]) },[]) console.log(斐波纳契(8))

其他人已经回答了这个问题，但我认为我应该提出另一种方法。你可以结合一个映射(从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;});

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

您可以使用减少方法如下所示;如果您将0(零)更改为1或其他数字，它会将其添加到总数中。例如，这个例子给出的总数是31，但是如果我们把0改为1，总数将是32。

const batteryBatches = [4, 5, 3, 4, 4, 6, 5];

let totalBatteries= batteryBatches.reduce((acc,val) => acc + val ,0)

在第一步中，它会工作得很好，因为a的值将是1,b的值将是2，但由于2+1将返回，在下一步中，b的值将是第一步的返回值，即3，因此b.x将是未定义的…而undefined + anyNumber将是NaN，这就是为什么你会得到这个结果。

相反，你可以尝试给初始值为零，即

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

为了将所指出的内容形式化，reducer是一种变形，它接受两个可能碰巧是同一类型的参数，并返回与第一个参数匹配的类型。

function reducer (accumulator: X, currentValue: Y): X { }

这意味着减速器的主体需要将currentValue和累加器的当前值转换为新累加器的值。

这在添加时以一种简单的方式工作，因为累加器和元素值恰好是同一类型(但用途不同)。

[1, 2, 3].reduce((x, y) => x + y);

因为它们都是数字。

[{ age: 5 }, { age: 2 }, { age: 8 }]
  .reduce((total, thing) => total + thing.age, 0);

现在我们给聚合器一个起始值。在绝大多数情况下，起始值应该是您期望聚合器的类型(您期望作为最终值出现的类型)。 虽然你没有被强迫这样做(也不应该这样做)，但记住这一点很重要。

一旦你知道了这一点，你就可以为其他n:1的关系问题写出有意义的约简。

去掉重复的单词:

const skipIfAlreadyFound = (words, word) => words.includes(word)
    ? words
    : words.concat(word);

const deduplicatedWords = aBunchOfWords.reduce(skipIfAlreadyFound, []);

提供所找到的所有单词的计数:

const incrementWordCount = (counts, word) => {
  counts[word] = (counts[word] || 0) + 1;
  return counts;
};
const wordCounts = words.reduce(incrementWordCount, { });

将数组的数组缩减为单个平面数组:

const concat = (a, b) => a.concat(b);

const numbers = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
].reduce(concat, []);

任何时候，当您希望从一个数组转换到一个不匹配1:1的值时，都可以考虑reduce。

事实上，map和filter都可以实现为约简:

const map = (transform, array) =>
  array.reduce((list, el) => list.concat(transform(el)), []);

const filter = (predicate, array) => array.reduce(
  (list, el) => predicate(el) ? list.concat(el) : list,
  []
);

我希望这为如何使用reduce提供了进一步的背景知识。

另外，我还没有详细说明的是，当期望输入和输出类型是动态的时，因为数组元素是函数:

const compose = (...fns) => x =>
  fns.reduceRight((x, f) => f(x), x);

const hgfx = h(g(f(x)));
const hgf = compose(h, g, f);
const hgfy = hgf(y);
const hgfz = hgf(z);

var arr = [{x:1}, {x:2}, {x:3}];
arr.map(function(a) {return a.x;})
.reduce(function(a, b) {return a + b});
console.log(arr);
//I tried using the following code and the result is the data array
//result = [{x:1}, {x:2}, {x:3}];
var arr2 = [{x:1}, {x:2}, {x:3}]
.reduce((total, thing) => total + thing.x, 0);
console.log(arr2);
// and I changed the code to like this and it worked.
// result = 6