谈谈 JavaScript 纯函数

一、什么是纯函数

纯函数，即相同的输入，永远会得到相同的输出，而且没有任何可观察的副作用。

比如 slice 和 splice，这两个函数的作用并无二致——但它们各自的方式却大不同。
其中，slice 符合纯函数的定义，因为对相同的输入它保证能返回相同的输出：

var xs = [1, 2, 3, 4, 5];

// 纯的
xs.slice(0, 3);
//=> [1,2,3]

xs.slice(0, 3);
//=> [1,2,3]

xs.slice(0, 3);
//=> [1,2,3]

而 splice 却会嚼烂调用它的那个数组，然后再吐出来，这就会产生可观察到的副作用，即原数组永久地改变了：

var xs = [1, 2, 3, 4, 5];

// 不纯的
xs.splice(0, 3);
//=> [1,2,3]

xs.splice(0, 3);
//=> [4,5]

xs.splice(0, 3);
//=> []

在函数式编程中，我们追求的是那种可靠的，每次都能返回相同结果的纯函数，而不是像 splice 这样每次调用后都把数据弄得一团糟的函数。

来看看另一个例子：

// 不纯的
var minimum = 21;
var checkAge = function (age) {
  return age >= minimum;
};


// 纯的
var checkAge = function (age) {
  var minimum = 21;
  return age >= minimum;
};

在不纯的版本中，checkAge 的结果将取决于 minimum 这个可变变量的值。
换句话说，它取决于系统状态（system state），这便引入了外部的环境，增加了认知负荷（cognitive load），而使用纯函数的形式，函数就能做到自给自足。

另外，我们可以让 minimum 成为一个不可变（immutable）对象，这样就能保留纯粹性，因为状态不会有变化。要实现这个效果，必须得创建一个对象，然后调用 Object.freeze 方法：

var immutableState = Object.freeze({
  minimum: 21
});

二、副作用

我们在纯函数定义中提到的副作用是什么呢？

副作用是在计算结果的过程中，系统状态的一种变化，或者与外部世界进行的可观察的交互。

副作用包括但不限于：

• 更改文件系统
• 往数据库插入记录
• 发送一个 http 请求
• 可变数据
• 打印/log
• 获取用户输入
• DOM 查询
• 访问系统状态

概括来讲，只要是跟函数外部环境发生的交互就都是副作用。
函数式编程的哲学就是假定副作用是造成不正当行为的主要原因，这并不是说要禁止使用一切副作用，而是要让它们在可控的范围内发生。

副作用让一个函数变得不纯是有道理的：从定义上来说，纯函数需根据相同的输入返回相同的输出；如果函数需要跟外部事物打交道，则无法保证这一点。

下面通过数学中的函数来了解下为何要坚持「相同输入得到相同输出」原则：

数学中函数的定义：

函数是不同数值之间的特殊关系：每一个输入值返回且只返回一个输出值。

换句话说，函数只是两种数值之间的关系：输入和输出。
这是一个合法的从 x 到 y 的函数关系：

下面这种就不是一种函数关系，因为输入值 5 指向了多个输出：

纯函数就是数学上的函数，而且是函数式编程的全部，使用这些纯函数编程能够带来大量好处。

三、纯函数好在哪里

1、可缓存性（Cacheable）

首先，纯函数总能够根据输入来做缓存。实现缓存的一种典型方式是 memoize 技术：

var squareNumber = memoize(function (x) { return x * x; });

squareNumber(4);
//=> 16

squareNumber(4); // 从缓存中读取输入值为 4 的结果
//=> 16

squareNumber(5);
//=> 25

squareNumber(5); // 从缓存中读取输入值为 5 的结果
//=> 25

下面代码是一个简单的实现：

var memoize = function (f) {
  var cache = {};

  return function () {
    var arg_str = JSON.stringify(arguments);
    cache[arg_str] = cache[arg_str] || f.apply(f, arguments);
    return cache[arg_str];
  };
};

值得注意的是，可以通过延迟执行的方式把不纯的函数转换为纯函数：

var pureHttpCall = memoize(function (url, params) {
  return function () { return $.getJSON(url, params); }
});

这里并没有真正发送 http 请求——只是返回了一个函数，当调用它时才会发请求。
这个函数之所以是纯函数，是因为它总是会根据相同的输入返回相同的输出：给定了 url 和 params 之后，它就只会返回同一个发送 http 请求的函数。

这个 memoize 函数工作起来没有任何问题，虽然它缓存的并不是 http 请求所返回的结果，而是生成的函数。

这种方式可以缓存任意一个函数，不管它们看起来多么具有破坏性。

2、可移植性／自文档化（Portable / Self-Documenting）

纯函数是完全自给自足的，它需要的所有东西都能轻易获得。
这种自给自足的好处是什么呢？
首先，纯函数的依赖很明确，因此更易于观察和理解——没有偷偷摸摸的小动作：

// 不纯的
var signUp = function (attrs) {
  var user = saveUser(attrs);
  welcomeUser(user);
};

var saveUser = function (attrs) {
  var user = Db.save(attrs);
    ...
};

var welcomeUser = function (user) {
  Email(user, ...);
    ...
};

// 纯的
var signUp = function (Db, Email, attrs) {
  return function () {
    var user = saveUser(Db, attrs);
    welcomeUser(Email, user);
  };
};

var saveUser = function (Db, attrs) {
    ...
};

var welcomeUser = function (Email, user) {
    ...
};

这个例子表明，纯函数对于其依赖必须要诚实，这样我们就能知道它的目的。仅从纯函数版本的 signUp 的签名可以看出，它将要用到 Db、Email 和 attrs，这在最小程度上给了我们足够多的信息。

相比不纯的函数（难以知道它们暗地里做了什么），纯函数能够提供多得多的信息。

在 JavaScript 的设定中，可移植性可以意味着把函数序列化（serializing）并通过 socket 发送。也可以意味着代码能够在 web workers 中运行。总之，可移植性是一个非常强大的特性。

命令式编程中“典型”的方法和过程都深深地根植于它们所在的环境中，通过状态、依赖和有效作用（available effects）达成；纯函数与此相反，它与环境无关，可以在任何地方运行它。

3、可测试性（Testable）

纯函数让测试更加容易。我们不需要伪造一个“真实的”支付网关，或者每一次测试之前都要配置、之后都要断言状态（assert the state）。只需简单地给函数一个输入，然后断言输出就好了。

Quickcheck，一个为函数式环境量身定制的测试工具。

4、合理性（Reasonable）

纯函数最大的好处是引用透明性（referential transparency）。如果一段代码可以替换成它执行所得的结果，而且是在不改变整个程序行为的前提下替换的，那么我们就说这段代码是引用透明的。

由于纯函数总是能够根据相同的输入返回相同的输出，所以能够保证总是返回同一个结果，这也就保证了引用透明性。我们来看一个例子：

var Immutable = require('immutable');

var decrementHP = function (player) {
  return player.set("hp", player.hp - 1);
};

var isSameTeam = function (player1, player2) {
  return player1.team === player2.team;
};

var punch = function (player, target) {
  if (isSameTeam(player, target)) {
    return target;
  } else {
    return decrementHP(target);
  }
};

var jobe = Immutable.Map({ name: "Jobe", hp: 20, team: "red" });
var michael = Immutable.Map({ name: "Michael", hp: 20, team: "green" });

punch(jobe, michael);
//=> Immutable.Map({name:"Michael", hp:19, team: "green"})

decrementHP、isSameTeam 和 punch 都是纯函数，所以是引用透明的。我们可以使用一种叫做“等式推导”（equational reasoning）的技术来分析代码。所谓“等式推导”就是“一对一”替换，有点像在不考虑程序性执行的怪异行为（quirks of programmatic evaluation）的情况下，手动执行相关代码。我们借助引用透明性来剖析一下这段代码。

首先内联 isSameTeam 函数：

var punch = function (player, target) {
  if (player.team === target.team) {
    return target;
  } else {
    return decrementHP(target);
  }
};

因为是不可变数据，我们可以直接把 team 替换为实际值：

var punch = function (player, target) {
  if ("red" === "green") {
    return target;
  } else {
    return decrementHP(target);
  }
};

if 语句执行结果为 false，所以可以把整个 if 语句都删掉：

var punch = function (player, target) {
  return decrementHP(target);
};

如果再内联 decrementHP，我们会发现这种情况下，punch 变成了一个让 hp 的值减 1 的调用：

var punch = function (player, target) {
  return target.set("hp", target.hp - 1);
};

总之，等式推导带来的分析代码的能力对重构和理解代码非常重要。

5、并行代码

可以并行运行任意纯函数，因为纯函数根本不需要访问共享的内存，而且根据其定义，纯函数也不会因副作用而进入竞争态（race condition）。

并行代码在服务端 js 环境以及使用了 web worker 的浏览器中很容易实现，因为它们使用了线程（thread）。不过出于对非纯函数复杂度的考虑，当前主流观点还是避免使用这种并行。