JS 函数式编程(1)

2015-11-07

要是在两三年前,我会说,函数式编程还没真正火起来。可现在,我只能遗憾地说,函数式编程终究没有火起来。

倒不是说函数式编程不好,而是对大多数程序员而言,尤其是习惯了面向过程、面向对象的程序员,函数式编程确实有些曲高和寡。

虽然像 Lisp、Haskell、Clojure、Erlang 这样的函数式编程语言没能广泛流行起来,但函数式编程的思想逐渐被一部分语言重视并借鉴,例如风头正劲的 JavaScript。

本文将作为一个系列的开篇,从基础知识开始,一步一步地介绍 JavaScript 函数式编程。

纯函数

纯函数是这样一种函数:对于同样的输入必会有相同的输出,无论何时,无论何地。

纯函数的唯一输入就是函数参数,唯一的输出就是返回值。纯函数的入参都是值传递,而非引用传递,因此它无法改变外部变量的值。

举一个典型的例子:

slice 是纯函数。splice 就不是纯函数,因为它会切断入参数组。

var a = [1, 2, 3];

a.slice(0, 1);
console.log(a); // => [1, 2, 3]

a.splice(0, 1);
console.log(a); // => [2, 3]

纯函数的好处

面向对象想必大家都很熟悉了。它符合人的常规思维,又好理解又好用,但是 Erlang 语言的作者 Joe Armstrong 说:

面向对象语言的问题是,它们永远都要随身携带那些隐式的环境。你只需要一个香蕉,但却得到一个拿着香蕉的大猩猩…以及整个丛林。

纯函数有哪些好处呢?

  1. 因为相同输入的输出是确定的,于是可以放心做缓存。入参序列化后得到一个字符串,当做字典的 key,如果 key 在缓存字典中能找到,value 必然和上一次计算结果相同,就不用再计算一遍了。

  2. 可移植性。因为不依赖状态,就能够序列化后放心地传递到其他线程、进程或者其他主机。比如可以将数据和函数传给 web worker 而不必担心它还要引用主线程的什么东西。

  3. 测试简单。因为不依赖上下文和状态,只要关注入参和返回值,执行顺序什么的都不用考虑,写测试用例再也不需要顾虑重重了。

  4. 并行简单。不共享内存、不用锁,对并行来说各种福利啊。

闭包

闭包的概念,我没有找到特别好的解释,不如通过代码来理解。

function f1() {
var n = 0;
function f2() {
console.log(n++);
}
return f2;
}

以上代码中,函数 f2 就是闭包,它可以读写它外部的函数 f1 中定义的变量,并且保留这个变量在内存中不被释放。

var func = f1();
func(); // => 0
func(); // => 1
func(); // => 2
func(); // => 3

上面这段代码中,每次调用 func(即f2) 都会让 n 增加 1,并且保留 n 改变后的值。

因为 n 定义在 f1 内部,从外面无法访问到,所以除非用闭包,否则无法访问到 n。

JavaScript 代码中,经常会看到结合了 IIFE(Immediately Invoked Function Expression) 和闭包两个特性来实现“私有变量”。例如下面两端代码,除了通过闭包再无方法访问 n 的值。

var counter = (function () {
var n = 0;
return function() {
console.log(n++);
}
})();

counter(); // => 0
counter(); // => 1
counter(); // => 2
var obj = (function () {
var n = 0;
return {
get: function () {
return n;
},
set: function (value) {
n = value;
}
}
})();

console.log(obj.get()); // => 0
obj.set(1000);
console.log(obj.get()); // => 1000

JavaScript 函数式编程,使用闭包是很重要的一个技巧,务必熟练掌握。

下面再看两个可爱的小栗子:

// Example 1
function makeAdder(increment){
return function (n) {
return n + increment;
}
}

var add10 = makeAdder(10);
var add1000 = makeAdder(1000);

console.log(add10(1)); // 11
console.log(add1000(1)); // 1001

这个例子中 makeAdder 函数返回值是一个函数,于是我们用函数生成了两个函数,这两个函数做了相似但不同的事情,一个加 10,一个加 1000。值得注意的是,这过程中只有函数的调用,并没有定义中间变量,是闭包帮我们保存了中间变量。

// Example 2
function say(word){
return function (someone) {
return function (method){
return 'say ' + method(word) + ' to ' + someone;
}
}
}

var sayHelloTo = say('hello');

var sayHelloToHaskell = sayHelloTo('Haskell');
var sayHelloToCurry = sayHelloTo('Curry');

function loud (word){
return word.toUpperCase();
}
function inLowVoice (word){
return word.split('').join('~');
}

var sayHelloToHaskellLoudly = sayHelloToHaskell(loud);
var sayHelloToHaskellInLowVoice = sayHelloToHaskell(inLowVoice);
var sayHelloToCurryLoudly = sayHelloToCurry(loud);
var sayHelloToCurryInLowVoice = sayHelloToCurry(inLowVoice);

console.log(sayHelloToHaskellLoudly); // => say HELLO to Haskell
console.log(sayHelloToHaskellInLowVoice); // => say h~e~l~l~o to Haskell
console.log(sayHelloToCurryLoudly); // => say HELLO to Curry
console.log(sayHelloToCurryInLowVoice); // => say h~e~l~l~o to Curry

console.log(say('hello')('me')(loud)); // => say HELLO to me

这颗栗子稍微大了一点,不仅演示了把函数作为返回值,也演示了把函数作为参数的用法。其中 loud 和 inLowVoice 这两个函数就被当做参数使用了。

代码实现的功能本身很无聊,但意思表达清楚了:就是通过不断传入参数返回新函数的方法,一步步将简单的函数变复杂、变具体,变得携带业务逻辑。整个过程中无需定义变量来保存状态。

注意最后一行代码,是函数连续调用,前一个函数返回的值是个函数,于是接着调用这个函数,返回又一个函数,直到最终结果出来。

通过上面的例子,还无法展现函数式编程的优势。先找找感觉,精彩的还在后面。

回主页 RSS 订阅
京ICP备14007233-1号