如何成为一位函数式编程爱好者(Part 4)

踏出理解函数式编程概念的第一步是最重要的一步，有时也是最难的一步。不过也不一定，取决于你们的思考方式。

柯里化

如果你还记得Part 3的内容，我们在组合mult5和add的时候遇到了问题，因为mult5接收一个参数而add接收两个。

只要限制所有函数都只接收一个参数，就可以轻松地解决这个问题。

相信我。这没听上去那么糟。

我们创建一个add函数，它接收两个参数，但是每次只接收一个参数。柯里化函数允许我们这么做。

柯里化函数是一种每次只接收一个参数的函数。

它允许我们在add与mult5组合前先传入它的第一个参数。

JavaScript里，我们可以这样实现add函数：

var add = x => y => x + y

这个版本的add是一个先接收一个参数，之后再接收另一个参数的函数。

具体来说，这个add接收单一参数x，然后返回一个接收单一参数y的函数，这个函数最终返回x和y的加和。

现在可以用这个版本的add来构建一个可用的mult5AfterAdd10了：

var compose = (f, g) => x => f(g(x));
var mult5AfterAdd10 = compose(mult5, add(10));

compose函数接收两个参数，f和g。返回一个接收一个参数x的函数，x会先传入g执行后，结果再传入f。

实际上我们做了什么？我们将旧的add函数转换成了柯里化版本。让add更加灵活，因为它的第一个参数10可以提前传入，最后一个参数可以在mult5AfterAdd10调用时再传入。

现在，你可能想知道在Elm中这个add函数要如何重写。事实证明，根本不需要重写。在Elm和其它函数式编程语言中，所有函数都是自动柯里化的。

所以add函数看上去和之前一样：

add x y =
    x + y

Part 3中的mult5AfterAdd10需要这样重写：

mult5AfterAdd10 =
    (mult5 << add 10)

从语法上讲，Elm要优于像JavaScript这样的指令式语言，因为它对柯里化，函数组合等函数式的东西做了优化。

柯里化和重构

柯里化的另一个好处则体现在重构时，创建一个接收多参数的通用版函数，然后在需要用的地方通过传入部分参数创建出指定版本的函数。

举个例子，当我们需要下面两个将括号和双括号添加在字符串两侧的函数时：

bracket str =
    "{" ++ str ++ "}"
doubleBracket str =
    "{{" ++ str ++ "}}"

我们需要这么用：

bracketedJoe =
    bracket "Joe"
doubleBracketedJoe =
    doubleBracket "Joe"

我们可以将bracket和doubleBracket通用化：

generalBracket prefix str suffix =
    prefix ++ str ++ suffix

但现在每次调用generalBracket时都必须将括号传入：

bracketedJoe =
    generalBracket "{""Joe""}"
doubleBracketedJoe =
    generalBracket "{{""Joe""}}"

我们需要两全其美的办法。

如果把generalBracket的参数重新排序，我们可以利用函数自动柯里化的特点创建出bracket和doubleBracket：

generalBracket prefix suffix str =
    prefix ++ str ++ suffix
bracket =
    generalBracket "{""}"
doubleBracket =
    generalBracket "{{""}}"

注意，将静态参数（prefix和suffix）放在参数列表靠前的位置，可能改变的参数（str）放在后面，就可以轻松地创建出指定版本的generalBracket。

参数顺序对完全柯里化很重要。

还有一点，bracket和doubleBracket是point-free模式的，即str参数是隐式的。bracket和doubleBracket都在等待它们的最后一个参数。

现在可以像之前一样使用了：

bracketedJoe =
    bracket "Joe"
doubleBracketedJoe =
    doubleBracket "Joe"

但这次我们使用了通用化的柯里化函数generalBracket。

常用的功能函数

让我们看一下函数式语言里最常用的三个函数。

但在那之前，先看一眼下面这段JavaScript代码：

for (var i = 0; i < something.length; ++i) {
    // do stuff
}

这段代码有一个很严重的问题。但不是bug。问题在于这段代码其实是模板代码，即一遍一遍被重复的代码。

如果你用指令式语言，像Java, C#, JavaScript, PHP, Python等，就会发现这样的模板代码到处都是。

这就是它的错误所在。

所以让我们扼杀它。

从改变数组things开始：

var things = [1, 2, 3, 4];
for (var i = 0; i < things.length; ++i) {
    things[i] = things[i] * 10; // MUTATION ALERT !!!!
}
console.log(things); // [10, 20, 30, 40]

呃！！突变！

再试一次。这次我们不改变东西：

var things = [1, 2, 3, 4];
var newThings = [];
for (var i = 0; i < things.length; ++i) {
    newThings[i] = things[i] * 10;
}
console.log(newThings); // [10, 20, 30, 40]

好了，现在我们没有改变things但从技术上讲，我们改变了newThings。先不去管它。毕竟是在用JavaScript。一旦迁移到一个函数式语言，我们就再也不能进行突变操作。

这部分的重点在于理解这些函数是如何工作的，并使用它们减少糟糕的代码。

把这些代码放在一个函数中。我们将使用第一个常用函数map，它操作旧数组中的每个值，并返回一个新数组。

var map = (f, array) => {
    var newArray = [];
    for (var i = 0; i < array.length; ++i) {
        newArray[i] = f(array[i]);
    }
    return newArray;
};

注意函数f，它被传入map中了，所以我们可以通过f对数组中的每个值进行任意操作。

现在可以用map重写之前的代码了：

var things = [1, 2, 3, 4];
var newThings = map(v => v * 10, things);

看啊。没有for循环。也因此增强了可读性。

当然，从技术上讲，map函数里也是for循环。但至少我们不用再一遍一遍地写模板代码了。

现在来实现另一个常用函数来从数组中过滤值：

var filter = (pred, array) => {
    var newArray = [];
for (var i = 0; i < array.length; ++i) {
        if (pred(array[i]))
            newArray[newArray.length] = array[i];
    }
    return newArray;
};

注意判断函数pred，返回TRUE则保留item，丢弃则返回FALSE。

下例展示了filter如何从数组中过滤出奇数：

var isOdd = x => x % 2 !== 0;
var numbers = [1, 2, 3, 4, 5];
var oddNumbers = filter(isOdd, numbers);
console.log(oddNumbers); // [1, 3, 5]

使用新的filter函数比在for循环中进行逻辑判断更简单。

最后一个常用函数叫reduce。通常来说，它用来将一个list缩减成一个单一值，但实际上它可以做更多事情。

在函数式语言中这个函数也叫fold。

var reduce = (f, start, array) => {
    var acc = start;
    for (var i = 0; i < array.length; ++i)
        acc = f(array[i], acc); // f() takes 2 parameters
    return acc;
});

reduce函数接收一个缩减函数f，一个初始值start和一个数组。

注意缩减函数f，它接收两个参数，一个数组当前值，一个累加器acc。每次迭代f用这两个参数产生一个新的累加器。最终一次迭代完成后累加器被返回。

下面的例子可以帮助我们理解它如何工作：

var add = (x, y) => x + y;
var values = [1, 2, 3, 4, 5];
var sumOfValues = reduce(add, 0, values);
console.log(sumOfValues); // 15

注意add函数接收两个参数然后相加。我们的reduce期望接收一个接收两个参数的函数，它们才能很好的配合。

我们传入0作为起始值和传入数组的值进行加和。在reduce函数内部，sum随着迭代器累加。最终的累加值返回给sumOfValues。

map,filter,reduce中让我们可以对数组进行常用操作而不必重复写模板代码。

但在函数式语言中，他们更常用，因为在函数式语言中没有循环结构，只有递归。迭代器函数不只是极其有用。而且是必须的。

记在脑子里！！！！

这次先到这里。

在这个系列后面的部分，将要讨论引用完整性，执行顺序，类型等。

本文根据@Charles Scalfani的《So You Want to be a Functional Programmer (Part 4)》所译，整个译文带有我们自己的理解与思想，如果译得不好或有不对之处还请同行朋友指点。如需转载此译文，需注明英文出处:https://medium.com/@cscalfani/so-you-want-to-be-a-functional-programmer-part-4-18fbe3ea9e49#.hi2v7rnd1。