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

如果看完了还不过瘾?想和作者深聊相关话题,可以点击这里向作者提问!

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

柯里化

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

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

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

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

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

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

JavaScript里,我们可以这样实现add函数:

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

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

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

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

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

compose函数接收两个参数,fg。返回一个接收一个参数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"

我们可以将bracketdoubleBracket通用化:

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

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

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

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

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

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

注意,将静态参数(prefixsuffix)放在参数列表靠前的位置,可能改变的参数(str)放在后面,就可以轻松地创建出指定版本的generalBracket

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

还有一点,bracketdoubleBracketpoint-free模式的,即str参数是隐式的。bracketdoubleBracket都在等待它们的最后一个参数。

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

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

Heng温

前端开发,音乐,动漫,技术控,喜欢折腾新鲜事物,以不断学习的态度,在前端的路上走下去。

如需转载,烦请注明出处:http://www.w3cplus.com/javascript/so-you-want-to-be-a-functional-programmer-part-4.html

如需转载,烦请注明出处:https://www.w3cplus.com/javascript/so-you-want-to-be-a-functional-programmer-part-4.html

如果文章中有不对之处,烦请各位大神拍正。如果你觉得这篇文章对你有所帮助,打个赏,让我有更大的动力去创作。(^_^)。看完了?还不过瘾?点击向作者提问!

赏杯咖啡,鼓励他创作更多优质内容!
返回顶部