这是一个简单的例子: a是我们想要返回的单个值，因此不需要 f。

顺便说一下，这就是我们之前没有在 A类中强制使用 reduce 的原因: 因为它只包含一个值。在数组上是强制性的，因为数组可以包含多个值。

因为只有当你有2个或者更多的值时才会调用 reduce，所以说它的唯一目的就是把它们合并起来只是一步之遥。

On transforming values

对于可变长度的数组，期望约简器转换值是危险的，因为正如我们所发现的，它可能不会被调用。

当你需要转换值和改变形状时，我鼓励你在 reduce之前先转换 map。

无论如何，为了可读性，将这两个关注点分开是一个好主意。

什么时候不用还原剂

因为 reduce是实现结构转换的通用工具，所以我建议您在需要返回数组时避免使用它，如果存在另一个更集中的方法，该方法可以满足您的需要。

具体来说，如果您在使用 map中的嵌套数组时遇到困难，请在使用 reduce之前考虑 flatMap或 flat。

在减少的核心

递归二元运算

在数组上实现 reduce引入了这个反馈回路，其中约简器的第一个参数是前一次迭代的返回值。

不用说，它看起来一点也不像 map的回调。

我们可以像这样递归地实现 Array.reduce:

const reduce = (f, acc, [current, ...rest]) =>
rest.length == 0
? f(acc, current)
: reduce(f, f(acc, current), rest)

这突出显示了简化程序 f的二进制特性，以及它的返回值在下一次迭代中如何成为新的 acc。

我让你说服自己以下是真的:

reduce(f, a, [b, c, d])


// is equivalent to
f(f(f(a, b), c), d)


// or if you squint a little
((a ❋ b) ❋ c) ❋ d

This should seem familiar: you know arithmetic operations obey rules such as "associativity" or "commutativity". What I want to convey here is that the same kind of rules apply.

reduce可能会去掉周围的结构，这些数值在转换的时候仍然被绑定在一个代数结构中。

还原代数

代数结构远远超出了这个答案的范围，所以我将只触及它们是如何相关的。

((a ❋ b) ❋ c) ❋ d

Looking at the expression above, it is self-evident that there is a constraint that ties all the values together : ❋ must know how to combine them the same way + must know how to combine 1 + 2 and just as importantly (1 + 2) + 3.

最脆弱的安全结构

One way to ensure this is to enforce that these values belong to a same set on which the reducer is an "internal" or "closed" binary operation, that is to say: combining any two values from this set with the reducer produces a value which belongs to the same set.

在抽象代数中这被称为 岩浆。你也可以查找 半群，这是更多的谈论，是相同的事情与结合(没有大括号需要) ，虽然 reduce不关心。

更不安全

生活在岩浆中并不是绝对必要的: 我们可以想象这样一种情况: ❋可以结合 a和 b，但不能结合 c和 b。

An example of this is function composition. One of the following functions returns a string, which constrains the order in which you can combine them:

const a = x => x * 2;
const b = x => x ** 2;
const c = x => x + ' !';


// (a ∘ b) ∘ c
const abc = x => c(b(a(x)));
abc(5); // "100 !"


// (a ∘ c) ∘ b
const acb = x => b(c(a(x)));
acb(5); // NaN

像许多二进制运算一样，复合函数可以用作减速器。

知道我们是否处于重新排序或从数组中删除元素可能导致 reduce中断的情况是有价值的。

所以，岩浆: 不是绝对必要的，但是非常重要。

初始值呢

假设我们想通过引入一个初始值来防止在数组为空时抛出异常:

array.reduce(f, init)


// which is really the same as doing
[init, ...array].reduce(f)


// or
((init ❋ a) ❋ b) ❋ c...

We now have an additional value. No problem.

"No problem"!? We said the purpose of the reducer was to combine the array values, but init is not a 没错 value: it was forcefully introduced by ourselves, it should not affect the result of reduce.

问题是:

我们应该选择哪个 init使得 f(init, a)或 init ❋ a返回 a？

我们需要一个初始值，它的作用就像它不存在一样。我们需要一个中立的元素(或“身份”)。

你可以查找 单位岩浆或者 幺半群(和结合性一样) ，这些词都是指含有中性元素的岩浆。

一些中性元素

你已经知道一些中性元素了

numbers.reduce((a, b) => a + b, 0)


numbers.reduce((a, b) => a * b, 1)


booleans.reduce((a, b) => a && b, true)


strings.reduce((a, b) => a.concat(b), "")


arrays.reduce((a, b) => a.concat(b), [])


vec2s.reduce(([u,v], [x,y]) => [u+x,v+y], [0,0])


mat2s.reduce(dot, [[1,0],[0,1]])

您可以对多种抽象重复此模式。注意，中性元素和计算不需要如此简单(极端的例子)。

中立元素困境

我们必须接受这样一个事实，即某些减少只对非空数组是可能的，并且添加差劲的初始化程序并不能解决问题。

Some examples of reductions gone wrong:

numbers.reduce((a, b) => b - a, 0)


// does not work
numbers.reduce((a, b) => a - b, 0)

从 b中减去 0返回 b，但从 0中减去 b返回 -b。 我们说只有“权利认同”是真实的。

Not every non-commutative operation lack a symmetrical neutral element but it's a good sign.

const min = (a, b) => a < b ? a : b;


// Do you really want to return Infinity?
numbers.reduce(min, Infinity)

对于非空数组，Infinity是唯一不改变 reduce输出的初始值，但是我们不太可能希望它真的出现在我们的程序中。

中性元素不是我们为了方便而添加的 Joker 值。它必须是一个允许的值，否则它不能完成任何事情。

下面的减少依赖于位置，但是添加一个初始化器会自然地将第一个元素移动到第二个位置，这需要扰乱减少器中的索引来维持行为。

const first = (a, b, i) => !i ? b : a;
things.reduce(first, null);

const camelCase = (a, b, i) =>  a + (
!i ? b : b[0].toUpperCase() + b.slice(1)
);
words.reduce(camelCase, '');

接受数组不能为空这一事实并简化 reducers 的定义会干净得多。

此外，首字母值是退化的:

• null不是空数组的第一个元素。

• 空字符串绝不是有效的标识符。

没有办法用初始值来保持“第一性”的概念。

conclusion

代数结构可以帮助我们更系统地思考我们的程序。知道哪一个我们正在处理可以准确地预测我们可以期望从 reduce，所以我只能建议你查找他们。

更进一步

我们已经看到了 map和 reduce在结构上是如何如此不同，但它们并不像是两个孤立的东西。

我们可以用 reduce来表示 map，因为总是可以重新构建我们开始时使用的相同结构。

const map = f => (acc, x) =>
acc.concat(f(x))
;


const double = x => x * 2;
[1, 2, 3].reduce(map(double), []) // [2, 4, 6]

再进一步推进，就产生了诸如传感器之类的巧妙技巧。

我不会详细介绍它们，但是我希望你们注意到一些事情，它们将重复我们之前所说的。

传感器

首先让我们看看我们要解决什么问题

[1, 2, 3, 4].filter(x => x % 2 == 0)
.map(x => x ** 2)
.reduce((a, b) => a + b)
// 20

我们将迭代3次并创建2个中间数据结构。此代码是声明性的，但效率不高。传感器试图调和这两者。

首先介绍一些使用 reduce组合函数的实用工具，因为我们不打算使用方法链接:

const composition = (f, g) => x => f(g(x));
const identity = x => x;


const compose = (...functions) =>
functions.reduce(composition, identity)
;


// compose(a, b, c) is the same as x => a(b(c(x)))

现在注意 map和 filter波纹管的实现。我们传入这个 reducer函数，而不是直接连接。

const map = f => reducer => (acc, x) =>
reducer(acc, f(x))
;


const filter = f => reducer => (acc, x) =>
f(x) ? reducer(acc, x) : acc
;

仔细看看这个:
reducer => (acc, x) => [...]
在应用了回调函数 f之后，我们只剩下一个函数，它接受一个 reduce 作为输入并返回一个 reduce。

这些对称函数是我们传递给 compose的:

const pipeline = compose(
filter(x => x % 2 == 0),
map(x => x ** 2)
);

请记住，compose是用 reduce实现的: 我们的 composition函数是由对称函数组合而成的。

这个操作的输出是一个相同形状的函数: 期望一个减速器并返回一个减速器的东西，这意味着

• 我们有岩浆，只要它们有这个形状，我们就可以继续构成变形。
• 我们可以使用这个链，方法是将结果函数应用于一个 reduce，它将返回一个可以与 reduce一起使用的 reduce

如果你需要说服力的话，我让你把整件事扩大了。如果这样做，您将注意到转换将方便地从左到右应用，这与 compose的方向相反。

好吧，我们用这个怪胎:

const add = (a, b) => a + b;


const reducer = pipeline(add);


const identity = 0;


[1, 2, 3, 4].reduce(reducer, identity); // 20

我们已经将各种操作(如 map、 filter和 reduce)组合成一个单独的 reduce，只迭代一次，没有中间数据结构。

这可不是小成就！而且，仅仅根据语法的简洁性在 map和 reduce之间做出选择是无法得出这种方案的。

Also notice that we have full control over the initial value and the final reducer. We used 0 and add, but we could have used [] and concat (more realistically push performance-wise) or any other data-structure for which we can implement a concat-like operation.