内容提要

本书主要介绍如何通过ECMAScript 6将函数式编程技术应用于代码来降低代码的复杂性。

本书共三部分内容。第一部分“函数式思想”是为第二部分的学习作铺垫的，这一部分引入了对函数式JavaScript的描述，从一些核心的函数式概念入手，介绍了纯函数、副作用以及声明式编程等函数式编程的主要支柱；第二部分“函数式基础”重点介绍函数式编程的核心技术，如函数链、柯里化、组合、Monad等；第三部分“函数式技能提升”则是介绍使用函数式编程解决现实问题的方法。

本书循序渐进地将函数式编程的相关知识铺陈开来，以理论作铺垫，并辅以实例，旨在帮助读者更好地掌握这些内容。如果读者是对面向对象软件有一定的了解，且对现代Web应用程序挑战有一定认识的JavaScript开发人员，那么可以从中提升函数式编程技能。如果读者是函数式编程的初学者，那么可以将本书作为入门书籍仔细阅读，为今后的学习夯实基础。

序

在本科和研究生阶段，我的课程安排专注于面向对象设计，并将其作为软件系统规划与架构设计的唯一方法。像许多开发人员一样，我的职业生涯也是从编写面向对象代码开始的，并且基于该编程范式来构建整个系统。

在整个职业生涯中，我密切关注并学习编程语言，不仅是因为想要学习一些很酷的知识，也因为我对每种语言的设计决策和设计哲学都很感兴趣。新的语言会对如何解决软件问题提供不同的观点，新的范式可以达到相同的效果。虽然面向对象的方法仍然是软件设计的主流工作方式，但是学习函数式编程能够拓宽视野，因为该技术既能够单独使用，也可以与其他设计范例并用。

函数式编程已经存在多年。尽管我听说过Haskell、Lisp、Scheme以及近年流行的Scala、Clojure和F＃在表现力方面以及高效的平台上拥有优势，但起初我对此并不是很关心。随着时间的流逝，即使是传统上一直被认为很啰嗦的语言Java，也具有了一些让代码更简洁的函数式特性。最终，这项不起眼的技术变得让我无法抵挡。更令人难以置信的是，JavaScript这种大家都当成面向对象的语言，也可以作为函数式语言来使用了。事实证明，这正是JavaScript更强大、更高效的使用方法。我花了很长时间才发现这一点，所以希望能通过本书让你也意识到这一点，如此一来，你的JavaScript代码就不会变得过于复杂。

作为开发人员，我学会了如何使用函数式编程原则来创建模块化、表达性强且易于理解和测试的代码。毫无疑问，作为一名软件工程师，函数式编程让我脱胎换骨，所以我想记录下这些经验，将其放到一本书中。于是，我联系了Manning出版社，打算以Dart编程语言为基础来编写这本函数式编程的书。当时我正在使用Dart，并认为如果将它与我的函数式背景相结合，会产生一个非常有趣的未知领域。因此，我拟定了一个写作方案，并在一个星期后与出版社的人进行了沟通——我了解到Manning正在寻找人写一本关于JavaScript函数式编程的书。因为JavaScript也是我非常痴迷的语言，所以我毫不犹豫地抓住了这个机会。通过这本书，我希望能帮助你提升这方面的技能，并为你的发展带来新的方向。

前言

复杂性是一头需要驯服的巨兽，我们永远无法完全摆脱它，而它也将永远是软件开发的一部分。我曾尝试花费无数小时和无法估量的脑力试图了解一段特定的代码。函数式编程能够帮助你控制代码的复杂性，使其不会与代码库的大小成正比。我们正在编写越来越多的JavaScript代码。我们已经经历了小型客户端事件处理程序的构建、富客户端架构以及同构（服务器+客户端）JavaScript应用程序的实现。函数式编程不是一种工具，而是一种可以同时适用于任何环境的思维方式。

本书旨在说明如何通过ECMAScript 6将函数式编程技术应用于代码。本书以渐进、稳定的速度呈现，涵盖了函数式编程的理论和实践两个方面，还为高级读者提供了更多信息，以帮助他们深入了解一些更高级的概念。

本书内容结构

本书分为三部分内容，指导读者学习从基础到函数式编程的更先进的应用。

第一部分“函数式思想”描绘了函数式JavaScript的高层次景观。它还讨论了如何像函数式程序员一样函数式地使用和思考JavaScript的核心。

• 第1章介绍了后续章节包含的一些核心的函数式概念（便于跨越到函数式），介绍了函数式编程的几个主要支柱，包括纯函数、副作用和声明式编程。
• 第2章为初级和中级JavaScript开发人员准备了练习场，高级的读者也可借此机会复习。本章还介绍了基本的函数式编程概念，为第二部分讨论的技术作铺垫。

第二部分“函数式基础”着重于核心函数式编程技术，包括函数链、柯里化、组合、Monad等。

• 第3章介绍了函数链，并探讨了如何使用递归和高阶函数组合成程序，如map、filter和reduce。其过程会使用到Lodash.js。
• 第4章介绍流行的提高代码模块化程度的技巧和组合。使用诸如Ramda.js之类的函数式框架。组合是编排整个JavaScript解决方案的黏合剂。
• 第5章带读者深入了解函数式编程的更多理论领域，并在错误处理的上下文中对Functor和Monad进行了全面并循序渐进的讨论。

第三部分“函数式技能提升”讨论了使用函数式编程解决现实世界挑战的优势。

• 第6章揭示了函数式程序易于进行单元测试的原因，还引入了一种严密的自动测试模式（称为基于属性测试 ）。
• 第7章介绍了JavaScript函数求值的内存模型。本章还讨论了有助于优化函数式JavaScript应用程序执行时间的技术。
• 第8章介绍了JavaScript开发人员在处理事件驱动和异步行为时经常遇到的一些主要挑战，讨论了函数式编程如何提供优雅的解决方案，以通过使用RxJS实现的称为响应式编程 的相关范例，来降低现有命令式解决方案的复杂性。

本书面向的读者

本书是针对对面向对象软件有基本了解，以及对现代Web应用程序挑战具有一定认识的JavaScript开发人员编写的。JavaScript是一种无处不在的语言，如果你需要函数式编程的介绍，并喜欢熟悉的语法，那么完全可以充分利用本书，而不是去学习Haskell（如果想要以更轻松的方式入门Haskell，本书不是最好的资源，因为每种语言都有自己的特性，直接学习其实是最好的理解）。

本书通过对高阶函数、闭包、函数调用、组合以及新的JavaScript ES6特性（如lambda表达式、迭代器、生成器和Promise）的介绍，帮助初级和中级程序员提高他们的JavaScript技能。高级开发人员也将从中领略到Monad和响应式编程的解读，从而可以运用创新的方法，来完成处理事件驱动和异步代码的艰巨任务，并充分地使用JavaScript平台。

如何使用本书

如果读者是初级或中级JavaScript开发人员，并且刚刚接触函数式编程，请从第1章读起。如果读者是一名高级JavaScript程序员，那么可以简要阅读第2章，然后从第3章的函数链和整体函数式设计读起。

函数式JavaScript的更高级用户通常已经理解纯函数、柯里化和组合，因此可以快速浏览第4章，并从第5章开始学习Functor与Monad。

示例和源代码

本书中的代码示例使用ECMAScript 6 JavaScript编写，它可以在服务器（Node.js）或客户端上运行。一些示例需要IO和浏览器DOM API，但没有考虑浏览器的兼容性。期望读者已经有在HTML页面和控制台的基础级互动的经验。代码对浏览器没有特定要求。

本书大量使用了诸如Lodash.js、Ramda.js等函数式的JavaScript库。读者可以在附录中找到文档和安装信息。

本书包含大量用于展示函数式技术的代码清单，并在适当的情况下比较了命令式和函数式设计。读者可以在Manning官方网站和GitHub上找到所有代码示例。

本书体例

本书中使用了以下约定：

粗体字 用于引用重要术语。

Courier 字体用于表示代码清单，以及元素和属性、方法名称、类、函数和其他编程工件。

代码清单中会有一些代码注释，以突出重要的概念。

第一部分　函数式思想

也许读者构建专业应用程序的大部分经验都与面向对象语言有关。读者可能通过阅读其他书籍、博客、论坛和杂志文章听说过函数式编程，但却从来没有编写过任何函数式代码。别担心，这正是笔者所想到的。笔者也曾在面向对象的环境中完成了大部分开发工作。编写函数式代码并不困难，但学会函数式的思考、放弃旧习惯才是真正的挑战。本书第一部分的主要目标是为第二部分和第三部分讨论的函数式技术奠定基础。

第1章讨论了什么是函数式编程，以及需要以什么样的心态来迎接它，同时还介绍了基于纯函数、不可变性、副作用和引用透明性等概念的一些重要技术。这些技术能够形成函数式代码的主干，并将帮助读者更轻松地走近函数式编程。此外，这也将成为后面章节中许多代码设计的指导原则。

第2章揭示了JavaScript作为函数式语言的另一面。由于Javascript是主流语言且广泛存在，因此这是一门理想的、可用来教授函数式编程的语言。如果读者不是一名高级JavaScript开发人员，本章将帮助你快速了解学习函数式JavaScript的必备基础，例如高阶函数、闭包和作用域规则。

第1章　走近函数式

本章内容

• 函数式思想
• 什么是函数式编程以及为什么要进行函数式编程
• 不变性和纯函数的原则
• 函数式编程技术及其对程序设计的影响

面向对象编程（OO）通过封装变化使得代码更易理解。

函数式编程（FP）通过最小化变化使得代码更易理解。

——Michael Feathers (Twitter)

如果你正在阅读这本书，那么很可能你已经是一名拥有面向对象或结构化设计工作经验的JavaScript软件开发人员，但你对函数式编程很感兴趣。或许你曾经尝试过学习它，但并不能在工作或个人项目中成功地应用它。这样的话，你的主要目标是增强开发技能，提高代码质量，那么本书可以帮助你实现这一目标。

Web平台的快速演进和浏览器的不断进化以及最重要的——用户的需求，给如今的Web应用的设计带来了意想不到的变化。人们期望Web应用给人的感觉应该更像本地的桌面应用，或是具有丰富且响应式的部件的移动应用。这样的期望自然而然地迫使JavaScript开发人员能够更广泛地去思考各种解决方案，并适时地采用那些可能提供最优解决方案的编程范式和最佳实践。

作为开发人员，我们总是更喜欢那些拥有简洁应用结构并可以增强软件扩展性的框架。然而代码库的复杂性仍然超出预期，这使得我们去重新审视这些代码的基本设计原则。此外，互联网对于JavaScript开发人员来说已今非昔比，因为今天的我们可以实现很多以前技术上不可行的东西了。我们可以用Node.js来编写大型的服务器端应用程序，还可以将大量的业务逻辑放到客户端去实现，使得服务端非常轻巧。这就需要与外部存储的交互、创建异步进程、处理事件，等等。

面向对象设计有助于解决一部分问题，但由于JavaScript是一种拥有很多共享状态的动态语言，用不了多久，代码就会积累足够的复杂性，变得笨拙而难以维护。面向对象设计的确能够一定程度地缓解这个问题，但我们需要的比缓解更多。也许最近几年你听说过响应式编程 这个术语。这种编程范式有助于数据流的处理和变化的传递。而在处理JavaScript中的异步或事件响应时，这一点至关重要。总之，我们需要一个能够引发我们对数据及其交互的函数深入思考的编程范式。当考虑应用设计时，你应该问问自己是否遵从了以下的设计原则。

• 可扩展性—— 我是否需要不断地重构代码来支持额外的功能？
• 易模块化—— 如果我更改了一个文件，另一个文件会不会受到影响？
• 可重用性—— 是否有很多重复的代码？
• 可测性—— 给这些函数添加单元测试是否让我纠结？
• 易推理性—— 我写的代码是否非结构化严重并难以推理？

如果对于这些问题，你的回答是“是”或是“不知道”，那么本书就能够指导你提高生产效率。函数式编程就是你需要的编程范式。尽管函数式编程基于一些简单的概念，但它还需要你换一种思考问题的方式。函数式编程不是一种新工具或新的API，而是另一种解决问题的方式，一旦你了解了它的基本原则，所要解决的问题将变得很直观。

本章将解释函数式编程的概念，并告诉你它那么有用和重要的原因，以及让其发挥作用的方法。我们将了解不变性和纯函数的核心原则，探讨函数式编程的技术，以及这些技术能够怎样影响程序的设计。这些技术能够使你更加轻松地学习响应式编程，并解决复杂的JavaScript任务。但在了解这一切之前，你需要知道为什么函数式思维方式如此重要的，以及它如何帮助解决JavaScript程序的复杂性。

1.1　函数式编程有用吗？

函数式编程的学习从未像今天这样重要。开发社区和各大软件公司都开始意识到使用函数式编程给其业务应用带来的好处。如今，大多数主流编程语言（如Scala、Java 8、F#、Python 和 JavaScript 等）都提供原生的或基于API的函数式支持。因此，行业对函数式编程技能的需求量很大，同时将在未来的几年不断增长。

在 JavaScript 的上下文中，函数式思想可以用来塑造令人难以置信的语言特性，帮助你编写干净的、模块化的、可测试的并且简洁的代码，使你在开发过程中更加高效。多年来，一个一直被忽略的事实是，JavaScript可以用函数式风格写得更加高效。部分原因是由于对JavaScript语言的整体理解偏差，另外也由于JavaScript缺乏一些能够妥当管理状态的原生结构——这种动态语言将管理状态的职责交给了开发人员（也是在程序中引入bug的原因之一）。这个问题并不会影响规模较小的脚本代码，但随着代码量的不断增长，会变得越来越难以控制。所以从某种程度上而言，我认为函数式编程能够在 JavaScript 中保护你不受该问题的影响。这个问题将在第2章进一步探讨。

编写函数式的 JavaScript 代码能够克服以上提到的大部分问题。通过使用一整套基于纯函数式的已被科学证明的技术与实践，即便复杂性日益提高，你也可以编写出易于推理和理解的代码。编写函数式的 JavaScript 是一件一举两得的事情，因为它不仅能够提高整个应用程序的质量，也能够更好地了解并精通 JavaScript 语言本身。

因为函数式编程是一种编写代码的方式，而不是一种框架或工具，函数式的思维方式与面向对象的思维方式完全不同。但如何迈向函数式呢？如何开始使用函数式去思考呢？一旦你掌握了它的本质，函数式编程将是直观的。摒弃旧习是最难的部分，对于一个有面向对象背景的人来说，将是一个巨大的编程范式转变。在学习如何使用函数式思考之前，首先你必须知道函数式编程到底是什么。

1.2　什么是函数式编程？

简单来说，函数式编程是一种强调以函数使用为主的软件开发风格。你可能会说，“就这样啊，我早就在日常的基本工作中使用函数了。有什么不一样么？”正如之前提到的，函数式编程需要你在思考解决问题的思路时有所变化。其实使用函数来获得结果并不重要，函数式编程的目标是使用函数来抽象作用在数据之上的控制流与操作 ，从而在系统中消除副作用 并减少对状态的改变 。我知道这听起来很拗口，但我将在书中进一步逐个地解释这些贯穿全书的术语。

通常情况下，函数式编程一类的书都会以斐波那契数列的计算为例开始讲解，但我更愿意以一个在HTML页面上显示文字的简单 JavaScript 程序作为开始。还有什么例子比输出一句经典的“Hello World”更好的呢？

document.querySelector('#msg').innerHTML = '<h1>Hello World</h1>';

注意

　

就像之前提到的，函数式编程不是一种具体的工具，而是一种编写代码的方式。因此，你既可以用它来编写客户端（基于浏览器的）程序，也可以用它来编写服务器端的应用程序（如Node.js）。打开浏览器、直接输入一段代码，这应该是让JavaScript运行起来的最简单的方式，而这也是本书需要你准备的所有东西。

这个程序很简单，但因为所有代码都是写死的，所以不能动态地显示消息。如果想改变消息的格式、内容或者目标DOM元素，就需要重写整个表达式。也许你决定用一个函数来封装这段代码，用参数来表明可变的部分。这样就可以只定义一遍，并通过不同的参数配置来使用它：

function printMessage(elementId, format, message) {
     document.querySelector(`#${elementId}`).innerHTML =
         `<${format}>${message}</${format}>`;
}

printMessage('msg', 'h1','Hello World');

这样确实有所改进，但它仍然不是一段可重用的代码。假设要将文本写入文件，而非 HTML 页面。你要形成一种简单的思维过程，即在另一个层面来创建参数化的函数，其参数不再只是量值，也可以是可以提供更多功能的函数。函数式编程就像是给函数打了激素，唯一目的就是执行并组合各种函数来实现更强大的功能。先展示一下函数式解决该问题的部分代码，如清单1.1所示。

清单 1.1　函数式的printMessage

var printMessage = run(addToDom('msg'), h1, echo);

printMessage('Hello World');

毫无疑问，这段代码与之前的完全不同。首先，h1 不再是一个量值了，它与 addToDom 和 echo 一样都是函数。这样看上去好像是用一些较小的函数构建了一个新的函数。

代码写成这样是有原因的。清单1.1将程序分解为一些更可重用、更可靠且更易于 理解的部分，再将它们组合起来，形成一个更易推理的程序整体。所有的函数式程序都遵循这一基本原则。从目前来看，要用一个神奇的函数run [1] 来序列地调用一系列的函数，例如addToDom 、h1 和echo 。后面会详细解释 run 函数。在后台，run 函数基本上是通过将一个函数的返回值作为下一个函数的输入这种方式将各个函数链接起来。这样，由 echo 返回的字符串“Hello World”被传递到 h1 中，而结果又最终被传递到 addToDom 里。

为什么函数式的解决方案是这样的呢？笔者更喜欢将其想成将代码本身参数化，这样以一种非侵入式的方式修改它 —— 例如修改一个算法的初始条件。基于这种方式，开发者可以轻松地增强 printMessage 来输出两遍文本，再换个 h2 的标题，最终将文本信息写入到控制台，而非 DOM 元素，而所有这些都无须重写任何内部的逻辑。代码如清单1.2所示。

清单1.2　扩展 printMessage

var printMessage = run(console.log, repeat(3), h2, echo);

printMessage('Get Functional');

这种视觉上不同的做法并非偶然。通过比较函数式和非函数式的解决方案，你会发现它们在代码风格上存在着根本区别。尽管它们的打印输出相同，但它们看起来却截然不同。这是源于函数式编程开发中固有的声明模式。为了充分理解函数式编程，读者首先必须知道它所基于的一些基本概念。

• 声明式编程。
• 纯函数。
• 引用透明。
• 不可变性。

1.2.1　函数式编程是声明式编程

函数式编程属于声明式 编程范式：这种范式会描述一系列的操作，但并不会暴露它们是如何实现的或是数据流如何穿过它们。目前，更加主流的是命令式 的或过程式 的编程范式，如Java、C#、C++ 和其他大多数结构化语言和面向对象语言都对其提供支持。命令式编程将计算机程序视为一系列自上而下的断言，通过修改系统的各个状态来计算最终的结果。

我们来看一个命令式的程序样例。假设你需要计算一个数组中所有数的平方，命令式的程序应有如下步骤：

var array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for(let i = 0; i < array.length; i++) {
   array[i] = Math.pow(array[i], 2);
}
array; //-> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

命令式编程很具体地告诉计算机如何 执行某个任务（在本例中是通过数组循环并将平方公式应用在每个数上）。这是编写代码的最常见方式，你在第一次实现该功能时很有可能也是这样写的。

而声明式编程是将程序的描述与求值分离开来的。它关注于如何用各种表达式 来描述程序逻辑，而不一定要指明其控制流或状态的变化。你可以在SQL语句中找到声明性编程的例子。SQL语句是由一个个描述查询结果应是什么的断言组成，对数据检索的内部机制进行了抽象。在第3章中，我们会看到一个使用类似SQL语句的模式组织起来的函数式代码，它能够同时描述应用程序及运行于其中的数据的意义。

如果使用函数式来解决相同的问题，只需要对应用在每个数组元素上的行为予以关注，将循环交给系统的其他部分去控制。完全可以让 Array.map() 去做这种繁重的工作：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].map(
     function(num) {
         return Math.pow(num, 2);  <--- map接收一个计算平方的函数
      });

//-> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

与之前的命令式代码相比，可以看到函数式的代码让开发者免于考虑如何妥善管理循环计数器以及数组索引访问的问题。简单地说，代码量越大，存在bug的地方就会越多。同时，标准的代码循环是很难被重用的东西，除非将它们抽象为函数。而这正是我们要去做的。在第3章中，我们将阐述如何使用如 map 、reduce 和 filter 这样的一等高阶函数来从代码中去除循环，它们都以函数为参数，可以增强代码的可重用性、可扩展性和声明性。这就是那个神奇的 run 函数在清单1.1和清单1.2中所做的事。

你可以发挥 ES6 JavaScript 的lambda表达式 以及箭头函数 的优势来将循环抽象成函数。lambda 表达式提供了一种匿名函数的简写方式，并可以作为函数类型的参数来传递，以减少代码的书写：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].map(num => Math.pow(num, 2));

//-> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

将 lambda 转换为常规函数

lambda 表达式提供了一种比常规函数更具语法优势的特性，因为它简化了常规函数的结构，使人关注于函数的那些真正重要的部分。下面的ES6 lambda表达式：

 num => Math.pow(num, 2)

等同于以下函数：

 function(num) {
   return Math.pow(num, 2);
 }

为什么要去掉代码循环？循环是一种重要的命令控制结构，但很难重用，并且很难插入其他操作中。此外，它意味着为响应新的迭代，代码会不断变化。你马上就会知道，函数式编程旨在尽可能地提高代码的无状态性 和不变性 。无状态的代码不会改变或破坏全局的状态。但要做到这一点，开发者要学会使用那些没有副作用和状态变化的函数——也称为纯函数 。

1.2.2　副作用带来的问题和纯函数

函数式编程基于一个前提，即使用纯函数构建具有不变性的程序。纯函数具有以下性质。

• 仅取决于提供的输入，而不依赖于任何在函数求值期间或调用间隔时可能变化的隐藏状态和外部状态。
• 不会造成超出其作用域的变化，例如修改全局对象或引用传递的参数。

直观地看，任何不符合以上条件的函数都是“不纯的”。编写不可变的程序起初会令人感到陌生。毕竟，我们所习惯的命令式程序设计的本质，就是声明一些从一个状态变为下一个状态的变量（毕竟它们是“变量”）。这是我们做起来很自然的事。考虑以下函数：

var counter = 0;
function increment() {
   return ++counter;
}

这个函数是不纯的，因为它读取并修改了一个外部变量，即函数作用域外的 counter 。一般来说，函数在读取或写入外部资源时都会产生副作用，如图1.1所示。另一个例子是经常见到的函数 Date.now() ，它的输出肯定是不可预见的并且不一致的，因为它总是依赖于一个不断变化的因素——时间。

图1.1　函数 increment() 通过读取 / 修改一个外部变量 counter 而产生副作用。其结果是不可预见的，因为 counter 可以在调用间隔的任何时间发生改变

在这个例子中，counter 可以通过一个隐式全局变量被访问到（在浏览器的 JavaScript 环境中，这个变量是window 对象）。另一种常见的副作用发生在通过this 关键字访问实例数据时。this 在JavaScript中的行为与其他编程语言中的不同，因为它决定了一个函数在运行时的上下文。而这往往就导致很难去推理代码，这就是为什么要尽可能地避免。我们将在下一章重温这个话题。在很多情况下，以下副作用都有可能发生。

• 改变一个全局的变量、属性或数据结构。
• 改变一个函数参数的原始值。
• 处理用户输入。
• 抛出一个异常，除非它又被当前函数捕获了。
• 屏幕打印或记录日志。
• 查询 HTML 文档、浏览器的 cookie或访问数据库。

如果无法创建和修改对象，或是打印到控制台，这样的程序会有什么实用价值？事实上，在一个充满了动态行为与变化的世界里，纯函数确实是很难使用的。但是，函数式编程在实践上并不限制一切 状态的改变。它只是提供了一个框架来帮助管理和减少可变状态，同时让你能够将纯函数从不纯的部分中分离出来。之前列出的那些不纯的代码都会产生外部可见的 副作用，而本书会探索处理该问题的方法。

为了更具体地讨论这些问题，假设你是一名开发人员，而你的团队正在实现一个用来管理学校学生数据的应用程序。清单1.3是一个短小的命令式程序，它能通过社会安全号码（SSN）找到一个学生的记录并渲染在浏览器中（同样，是不是使用浏览器并不重要，你也可以很容易地写入控制台、数据库或文件）。本书会涉及并扩展这个程序，因为它是一个典型的、真实的场景，其中包含了很多与外部的本地对象存储结构（例如一个对象数组）和不同层次的IO交互而产生的副作用。

清单1.3　命令式的 showStudent 函数以及产生的副作用

function showStudent(ssn) {
    var student = db.get(ssn);  <---在对象存储中通过SSN查找学生。请假设这个操作现在是同步的，之后我会处理异步的情况
    if(student !== null) {
       document.querySelector(`#${elementId}`).innerHTML =  <---读取函数外的elementId变量
          `${student.ssn},
           ${student.firstname},
           ${student.lastname}`;
    }
    else {
        throw new Error('Student not found!');  <---当学生信息错误时抛出异常
    }
}
showStudent('444-44-4444');  <---使用SSN号444-44-4444作为参数执行函数，结果会显示在页面上

进一步分析这段代码。这个函数显然将一些副作用暴露到其作用域之外：

• 该函数为访问数据，与一个外部变量（db ）进行了交互，因为该函数签名中并没有声明该参数。在任何一个时间点，这个引用可能为null ，或在调用间隔改变，从而导致完全不同的结果并破坏了程序的完整性。
• 全局变量 elementId 可能随时改变，难以控制。
• HTML 元素被直接修改了。HTML 文档（DOM）本身是一个可变的、共享的全局资源。
• 如果没有找到学生，该函数可能会抛出一个异常，这将导致整个程序的栈回退并突然结束。

一方面，清单1.3中的函数依赖了外部资源，使得代码很不灵活，很难维护并且难以测试。另一方面，使用纯函数，其函数签名对所描述的所有形参（输入集）都有明确的约定，使其更易于理解和使用。

再回到函数式的世界，用在简单的 printMessage 程序中学到的东西来应对这种真实的情况。在阅读本书时，你会逐渐适应函数式，而本书会不断地改进并应用新技术来实现这个任务。目前可以改进以下两点。

• 将这个长函数分离成多个具有单一职责的短函数。
• 通过显式地将完成功能所需的依赖都定义为函数参数来减少副作用的数量。

首先分离屏幕显示与获取学生记录的行为。当然，与外部存储系统和 DOM 交互所造成的副作用是不可避免的，但至少可以通过将其从主逻辑中分离出来的方式使它们更易于管理。要做到这一点，需要引入一种常见的函数式编程技巧——柯里化 。使用柯里化，可以允许部分地传递函数参数，以便将函数的参数减少为一个。就像在清单1.4中显示的那样，可以使用 curry 减少 find 和 append 的参数，使其成为可以与 run 组合的一元函数。

清单1.4　showStudent 程序的分解

var find = curry(function (db, id) {  <---函数find需要对象存储的引用和ID来查找学生
    var obj = db.get(id);
    if(obj === null) {
       throw new Error('Object not found!');
    }
    return obj;
});

var csv = (student) {  <---将学生对象转换成用逗号分隔的字符串
   return `${student.ssn}, ${student.firstname}, ${student.lastname}`;
};

var append = curry(function (elementId, info) {  <---为了在屏幕上显示学生信息，这里需要elementId以及学生的数据
   document.querySelector(elementId).innerHTML = info;
});

读者并不需要现在就理解如何柯里化，但要看到很重要的一点，那就是通过减少这些函数的长度，可以将 showStudent 编写为这些小函数的组合：

var showStudent = run(
   append('#student-info'),  <---部分设置HTML元素的ID
   csv,
   find(db));  <---部分设置查找对象为学生表

showStudent('444-44-4444');

尽管这个程序只有些许的改进，但是它开始展现出许多的优势。

• 它灵活了很多，因为现在有三个可以被重用的组件。
• 这种细粒度函数的重用是提高工作效率的一种手段，因为你可以大大减少需要主动维护的代码量。
• 声明式的代码风格提供了程序需要执行的那些高阶步骤的一个清晰视图，增强了代码的可读性。
• 更重要的是，与 HTML 对象的交互被移动到一个单独的函数中，将纯函数从不纯的行为中分离出来。柯里化以及如何管理纯与不纯的代码将在第4章进一步解释。

这个程序仍然有一些枝节问题需要解决，但减少副作用能够在修改各种外部条件时使程序不那么脆弱。如果仔细看一下 find 函数，就会发现它有一个可以产生异常的检查 null 值的分支。由于许多我们会在后续了解的原因，能够确保一个函数有相同的返回值是一个优点，它使得函数的结果是一致的和可预测的。这是纯函数的一个特质，称为引用透明 。

1.2.3　引用透明和可置换性

引用透明是定义一个纯函数较为正确的方式。纯度 在这个意义上表明一个函数的参数和返回值之间映射的纯的关系。因此，如果一个函数对于相同的输入始终产生相同的结果，那么就说它是引用透明 的。例如，之前看到的那个有状态的函数increment 不是引用透明的，因为其返回值严重依赖外部变量counter 。再看一下这段代码：

var counter = 0;

function increment() {
    return ++counter;
}

为了使其引用透明，需要删除其依赖的外部变量这一状态，使其成为函数签名中显式定义的参数。可以将其转换为 ES6 lambda 的形式：

var increment = counter => counter + 1;

现在这个函数是稳定的，对于相同的输入每次都返回相同的输出结果。否则，该函数的返回值总会受到一些外部因素的影响。

我们之所以追求这种函数的这种特质，是因为它不仅能使代码更易于测试，还可以让我们更容易推理整个程序 。引用透明（又称为等式正确性） 来自数学概念，但编程语言中的函数的行为和数学中的函数不同，所以引用透明必须由我们来实现。通过再次使用神奇的 run 函数，图1.2展示了increment 函数的命令式与函数式版本的对比。

图1.2　increment 函数的命令式与函数式版本的比较。命令式版本的结果是不可预测的，并且可能是不一致的。外部变量counter 随时会改变，这影响了函数连续调用的结果。而引用透明的函数式版本中，函数总是等式正确的，因此不可能出现任何错误

构建这样的程序更容易推理，因为可以在心中形成一个状态系统的模型，并通过重写 或替换 来达到期望的输出。具体来讲，假设任何程序可以被定义为一组的函数，对于一个给定的输入，会产生一个输出，则可表示为：

Program = [Input] + [func1, func2, func3, ...] -> Output

如果函数 [func1, func2, func3, ...] 都是纯的，则可以轻易地将由其产生的值来重写这个程序——[val1, val2, val3, ...] ——而不改变结果。考虑计算学生的平均成绩这样一个简单的例子：

var input = [80, 90, 100];
var average = (arr) => divide(sum(arr), size(arr));
average (input); //-> 90

由于函数 sum 和 size 都是引用透明的，对于如下的给定输入，可以很容易地重写这个表达式。

var average = divide(270, 3); //-> 90

由于 divide 总是纯的，因此可以利用其数学符号进一步改写，所以对于当前输入，平均值永远是 270/3=90 。引用透明使得开发者可以用这种系统的甚至是数理的方法来推导程序。整个程序可如下实现：

var sum = (total, current) => total + current;
var total = arr => arr.reduce(sum);　　　<---又一新函数：reduce。跟map一样，reduce遍历整个集合。通过sum函数，可以将叠加集合中的数
var size = arr => arr.length;
var divide = (a, b) => a / b;
var average = arr => divide(total(arr), size(arr));  <---在第4章中，我们会用新的方式组合average函数
average(input); //-> 90

尽管本书并不打算对每个程序进行这种等价推导，但应该知道这种形式隐式地存在于任何纯函数的程序，但对于有副作用的函数来说，这却是不可能的。在中，我们会在函数式单元测试的上下文中重识其重要性。虽然可以通过定义函数形参的方式来避免在大多数情况下的副作用，但是在用引用来传递对象时，一定要谨慎，不要在不经意间改变它们。

1.2.4　存储不可变数据

不可变数据 是指那些被创建后不能更改的数据。与许多其他语言一样，JavaScript中的所有基本类型（String 、Number 等）从本质上是不可变的。但是其他对象，例如数组，都是可变的——即使它们作为输入传递给另一个函数，仍然可以通过改变原有内容的方式产生副作用。考虑一个简单的数组排序代码：

var sortDesc = function (arr) {
  return arr.sort(function (a, b) {
     return b - a;
  });
}

乍一眼看去，这段代码看起来完全正常，并没有副作用。它确实如所期望的那样——给一个数组，返回以降序排序的相同数组：

var arr = [1,2,3,4,5,6,7,8,9];
sortDesc(arr); //-> [9,8,7,6,5,4,3,2,1]

不幸的是，array.sort 函数是有状态的，会导致在排序过程中产生副作用，因为原始的引用被修改了。这是语言的一个缺陷，我们将在后续的章节中克服它。

现在，读者已经了解了函数式编程的一些基本原则（如声名式的、纯的和不可变的），就可以更简洁地描述它：函数式编程是指为创建不可变的程序，通过消除外部可见的副作用，来对纯函数的声明式的求值过程。 ——还是比较拗口。之前只是通过编写函数式应用来获取一些显式的实践优势，但现在读者应该开始明白用函数式思考的意义了。

大多数 JavaScript 开发人员面临的问题都是由大量使用严重依赖外部共享变量的、存在太多分支的以及没有清晰的结构大函数所造成的。然而，这正是许多 JavaScript 应用今天的处境——即便是一些由很多文件组成并执行得很成功的应用，也会形成一种共享的可变全局数据网，难以跟踪和调试。

强迫自己去思考纯的操作，将函数看作永不会修改数据的闭合功能单元 ，必然可以减少这种潜在bug的可能性。理解这些核心的原则非常重要，它可以让代码发挥出函数式的诸多优势，从而引导你走向克服复杂性的函数式编程之路。

1.3　函数式编程的优点

为了从函数式编程中受益，你必须学会函数式的思考并掌握合适的工具。在本节中，为了增强函数式编程的意识 ，也就是将问题看作许多简单函数组合来提供完整解决方案的直觉，笔者将介绍一些工具箱中不可或缺的核心技术，还会简单地介绍一下本书的一些后续章节。如果某个概念现在很难把握，请不用担心，它将会在你阅读后续章节的过程中变得更加清晰明了。

现在来宏观地了解一下函数式能为JavaScript应用程序带来的好处。

• 促使将任务分解成简单的函数。
• 使用流式的调用链来处理数据。
• 通过响应式范式降低事件驱动代码的复杂性。

1.3.1　鼓励复杂任务的分解

从宏观上讲，函数式编程实际上是分解（将程序拆分为小片段）和组合（将小片段连接到一起）之间的相互作用。正是这种二元性，使得函数式程序如此模块化和高效。正如上文提到的，这里的模块化单元（或称为功能单元 ），就是函数本身。函数式思维的学习通常始于将特定任务分解为逻辑子任务（函数）的过程，图1.3所示的是对showStudent的分解。

图1.3　将 showStudent 分解为小片段的过程。这些子任务是相互独立并易于 理解的，这样在组合时，可以有助于解决最终的问题

如果需要，这些子任务可以进一步分解，直到成为一个个简单的、相互独立的纯函数功能单元。请记住，这是笔者在重构清单1.4 中showStudent时采用的思维方式。函数式编程的模块化的概念与单一职责 原则息息相关，也就是说，函数都应该拥有单一的目的——之前例子中的 average 函数正体现了这一原则。纯度和引用透明会促使你这样思考问题，因为为了将函数组合在一起，它们必须在输入和输出的形式上形成一致。通过引用透明的概念能够看出，函数的复杂性往往与其接收的参数数量相关（这更多是来自实际观察的结果，函数的参数越少就越简单并不是绝对的）。

笔者一直在使用run 函数来组合各种函数，从而实现整个程序。现在是时候揭秘这个黑魔法了。在现实中，run 函数是一个极为重要的技术的别名：组合 。两个函数的组合是一个新的函数，它拿到一个函数的输出，并将其传递到另一个函数中。假设有两个函数 f 和 g ，形式上，其组合可以如下描述：

f • g = f(g(x))

这个公式读作“f 组合上g ”，它在g 的返回值与f 的参数之间构建了一个松耦合的且类型安全的联系。两个函数能够组合的条件是，它们必须在参数数目及参数类型上形成一致（见第3章）。现在用compose 构建组合函数 showStudent ，其结构如图1.4所示。

var showStudent = compose(append('#student-info'), csv, find(db));

showStudent('444-44-4444');

图1.4　两个函数组合后的数据流。函数 find 的返回值必须与函数 csv 的参数在类型和数量上相兼容，而之后的返回值又必须是 append 函数可以使用的信息。 注意：为了使数据流明晰，函数调用的顺序被翻转了

了解compose 是学习如何实现函数式应用的模块化和可重用性的关键——笔者会在第4章详细讨论。函数式的组合表明了整个表达式的意义可以从其各个部分分别去理解，这是其他编程范式所难以实现的特性。

此外，函数式的组合提高了抽象的层次，可以清晰地勾勒代码的所有步骤，但又不暴露任何底层细节在此代码执行的所有步骤。由于 compose 接收其他函数为参数，这被称为高阶函数 。但组合并不是构建流式的、模块化的代码的唯一方式。在本书中，读者还将学习如何通过连接各种操作来构建链式的运行序列。

1.3.2　使用流式链来处理数据

除了map ，开发者可以通过导入一些功能强大的、最优化的函数式类库来获得更多的高阶函数。在第3章和第4章中，我们将介绍很多实现于像 Lodash.js 和 Ramda.js 这种流行的 JavaScript 工具包中的高阶函数。尽管它们在某些方面有所重叠，但每一个都带来了独特的、可简化函数链式装配的功能。

如果读者以前写过一些 jQuery 代码，那么可能熟悉一个词语——链。链 指的是一连串函数的调用，它们共享一个通用的对象返回值（如 $ 或 jQuery 对象）。就像组合一样，链有助于写出简明扼要的代码，而且它通常多用于函数式和响应式的JavaScript类库（后面会见到更多）。为了说明这一点，下面来解决一个不同的问题。假设需要用程序计算那些选了多门课程的学生的平均成绩。已知选课数据的数组：

let enrollment = [
  {enrolled: 2, grade: 100},
  {enrolled: 2, grade: 80},
  {enrolled: 1, grade: 89}
];

命令式的实现可能是这样的：

var totalGrades = 0;
var totalStudentsFound = 0;
for(let i = 0; i < enrollment.length; i++) {
    let student = enrollment [i];
    if(student !== null) {
       if(student.enrolled > 1) {
          totalGrades+= student.grade;
          totalStudentsFound++;
       }
    }
}
var average = totalGrades / totalStudentsFound; //-> 90

与之前一样，用函数式的思维来分解这个问题，可以发现有三个主要步骤。

• 选择合适的（选课数量大于1的）学生。
• 获取他们的成绩。
• 计算出他们的平均成绩。

这样就可以用 Lodash 缝合表征这些步骤的函数，形成一个清单1.5所示的函数链（如果想知道其中每一个函数的详细说明，可以查看附录中的相应文档）。函数链是一种惰性计算 程序，这意味着当需要时才会执行。这对程序性能是有利的，因为可以避免执行可能包含一些永不会使用的内容的整个代码序列，节省宝贵的CPU计算周期。这有效地模拟了其他函数式语言的按需调用 的行为。

清单1.5　使用函数链编程

_.chain(enrollment)
  .filter(student => student.enrolled > 1)
  .pluck('grade')
  .average()
  .value(); //-> 90  <---调用 _.value() 会触发整个链上的所有操作

目前不要太在意这段代码中发生的一切。当下，请与其命令式的版本进行比较，并注意如何消除变量的声明和变化，以及循环和 if-else 语句。正如你将在第7章所学的，诸如循环和逻辑分支这样的很多命令式控制流机制，会提高函数的复杂程度，因为它们会根据某些条件不同而执行不同的路径，非常难以测试。

公平地说，这个例子略过了一些真实世界程序中典型的错误处理代码。而上文提到抛出异常是产生副作用的一个原因。异常尽管不会存在于理论上的函数式编程之中，但在现实生活中，你将无法避免它们。其实，纯粹的错误处理和异常处理是有区别的。本书的目标是尽可能多地使用纯粹的错误处理，并在像之前描述的那些真正需要异常的情况下抛出异常。

幸运的是，利用一些纯函数式的设计模式，你将不需要通过牺牲函数链的描述性来为代码提供强大的错误处理逻辑。我们将在第5章讨论这个话题。

到目前为止，读者已经看到了如何使用函数式编程来帮助创建模块化的、可测试的以及可扩展的应用程序了。但如何利用函数式编程与来自用户输入、远程Web请求、文件系统或持久化存储的基于异步或事件驱动的数据进行交互呢？

1.3.3　复杂异步应用中的响应

如果读者还记得最近一次请求远程数据、处理用户输入或与本地存储交互的情况，也许能够想起是如何将整个业务逻辑放入回调函数的嵌套序列之中的。这种回调模式打破了线性的代码流，使代码变得难以阅读，因为它的成功处理和错误处理的逻辑混杂在一起。而这一切将得以改变。

正如之前所说，学习函数式编程，尤其是对于如今的JavaScript 开发人员是极其重要的。当构建大型应用程序时，大家关注的焦点从像 Backbone.js 这样的面向对象框架逐渐转移到像采用响应式编程范式这样的框架上。像 Angular.js 这样的 Web 框架今天仍然广为使用；但像 RxJS 这样的新成员，也在通过函数式编程赋予的力量解决着很多极具挑战的任务。

响应式编程可能是函数式编程最令人兴奋和感到有趣的应用之一。JavaScript 开发人员每天都需要处理那些在服务端或客户端中的异步和事件驱动的代码，而你可以使用响应式编程来大幅降低这些代码的复杂性。

采用响应式范式的主要好处是，它能够提高代码的抽象级别，使你忘记与异步和事件驱动程序创建的相关样板代码，从而更专注于具体的业务逻辑。此外，这种新兴范式能够充分利用函数式编程中函数链和组合的优势。

事件有很多种：鼠标点击、文本变化、焦点变化、新HTTP请求的处理、数据库查询以及文件写入，等等。假设需要读取并验证学生的社会保险号（SSN），那么典型的命令式代码可能是清单1.6所示的这样：

清单1.6　读取并验证学生的SSN 的命令式程序

var valid = false;
var elem = document.querySelector('#student-ssn');
elem.onkeyup = function(event) {
  var val = elem.value;  <---访问函数作用域外的数据会产生副作用
   if(val !== null && val.length !== 0) {
      val = val.replace(/^\s*|\s*$|\-s/g, '');  <---裁剪并清理输入，直接改变数据
     if(val.length === 9) {  <---嵌套的分支逻辑
         console.log(`Valid SSN: ${val}!`);
         valid = true;  <---访问函数作用域外的数据会产生副作用
      }
   }
   else {
      console.log(`Invalid SSN: ${val}!`);
   }
};

对于这样一个简单的任务，从一开始就变得复杂，并且代码缺乏一种将所有业务逻辑模块化的能力。此外，由于依赖于外部状态，该函数无法被重用。由于基于函数式编程，响应式编程也是使用像 map 、reduce 以及简洁的lambda表达式这样的纯函数来处理数据的。所以学习响应式编程的第一部分就是学习函数式编程！这种编程范式使用了一个叫作observable 的概念。observable 能够订阅一个数据流，让开发者可以通过使用组合和链式操作来优雅地处理数据。下面来看它的实际应用——订阅一个学生的 SSN 字段的简单输入，如清单1.7所示。

清单1.7　读取并验证学生 SSN 的函数式程序

Rx.Observable.fromEvent(document.querySelector('#student-ssn'), 'keyup')
   .map(input => input.srcElement.value)
   .filter(ssn => ssn !== null && ssn.length !== 0)
   .map(ssn => ssn.replace(/^\s*|\s*$|\-/g, ''))
   .skipWhile(ssn => ssn.length !== 9)
   .subscribe(
      validSsn => console.log(`Valid SSN ${validSsn}`)
   );

能看出清单1.7和采用链式编程的清单1.5的相似性吗？这说明，无论是处理集合元素序列或是用户输入序列，一切都被抽象了出来，这使得可以使用相同的方式去处理（本书第8章将会详细介绍）。

其中一个最重要的知识点是，所有清单1.7中的操作都是完全不可变的，并且所有的业务逻辑被分隔成单独的函数。并不是必须 要响应式地使用函数，但函数式的思维会迫使 开发者这样做。一旦这样做了，将解开一个基于函数式响应式编程 （FRP）的非常了不起的架构。

函数式编程是一种编程范式的转变，可以改变开发者对任何编程挑战的解决方式。那么，能说函数式编程是更为流行的面向对象设计的替代品么？幸运的是，就如本章开始 Michael Feathers 所说的，函数式编程对代码来说不是一个全有或全无的方案。事实上，很多采用面向对象架构的应用依然可以受益于函数式编程。由于对不可变性及状态共享的严格把控，函数式编程可以使得多线程编程更加简单。但由于 JavaScript 是单线程运行的，本书不会涵盖多线程编程。下一章会重点介绍一些函数式和面向对象设计的主要区别，帮助读者更容易地适应函数式的思维方式。

本章简要介绍了将在整本书中细致讨论的各个主题，让读者从思维方式上深入了解函数式的意境。不必担心遗漏一些东西，只要能够理解上述的所有概念，那么就很不错，这说明你选择了一本正确的书。在传统的面向对象编程中，读者习惯于采用命令式/过程式的编程风格。要改变这一点，思维过程需要有巨大的转变，要开始使用函数式的方式去解决问题。

1.4　总结

• 使用纯函数的代码绝不会更改或破坏全局状态，有助于提高代码的可测试性和可维护性。
• 函数式编程采用声明式的风格，易于推理。这提高了应用程序的整体可读性，通过使用组合和lambda表达式使代码更加精简。
• 集合中的数据元素处理可以通过链接如map 和reduce 这样的函数来实现。
• 函数式编程将函数视为积木，通过一等高阶函数来提高代码的模块化和可重用性。
• 可以利用响应式编程组合各个函数来降低事件驱动程序的复杂性。

[1] 更多关于这个临时的run函数的细节，请访问http://mng.bz/nmax 。

第2章　高阶JavaScript

本章内容

• 为什么说JavaScript是适合函数式的编程语言
• JavaScript语言的多范型开发
• 不可变性和变化的对策
• 理解高阶函数和一等函数
• 闭包和作用域的概念探讨
• 闭包的实际使用

自然语言是没有主导范式的，JavaScript 也同样没有。开发者可以从过程式、函数式和面向对象的“大杂烩”中选择自己需要的，再适时地把它们融为一体。

——Angus Croll，《If Hemingway Wrote JavaScript》

当应用程序变得越来越庞大，其复杂性也随之增加。无论你觉得自己有多么了不起，如果没有一个适合的编程模型，也少不了麻烦。第1章解释了为什么函数式编程是一个值得采用的编程范式。但范式本身也仅仅是编程模型，需要借助合适的宿主语言才能在现实中应用。

本章将带领读者快速领略JavaScript 这门集面向对象和函数式为一体的混合语言。当然，这决不是广泛地学习语言本身。相反，笔者将把重点放在JavaScript的函数式特性及其不足。其中一个例子就是缺乏对不可变性的支持。此外，本章还涵盖高阶函数和闭包，它们是编写函数式风格JavaScript的支柱。

2.1　为什么要使用JavaScript？

首先回答“为什么使用函数式？”这个问题。而这与另一个问题息息相关，“为什么要使用JavaScript？”，其答案也很简单：它无所不在。JavaScript是一种动态类型、面向对象且极具语法表现力的一门通用语言。它是有史以来应用最为广泛的程序语言之一，在移动应用、网站、网络服务器、桌面应用、嵌入式应用甚至是数据库的开发中都能够看到。作为Web语言 ，鉴于其应用之广泛，JavaScript成为有史以来使用最为广泛的函数式编程语言也就理所当然了。

尽管 JavaScript 拥有类似 C 语言的语法，其设计灵感有很多则来自像 Lisp 和 Scheme 这样的函数式语言。作为这些语言的共同点，对高阶函数、闭包、数组字面量以及其他特性的支持，使得JavaScript成为一个应用函数式技术的理想平台。事实上，函数是 JavaScript 中主要的工作单元 ，这意味着它们不仅用于驱动应用程序的行为，也用于定义对象、创建模块以及处理事件。

JavaScript 是一门积极演变与改进的语言。在 ECMAScript（ES）的标准支持下，它的下一个主要版本 ES6 增加了更多的语言特性：箭头函数、常量、迭代器、Promise 以及其他能够很好地配合函数式编程的特性。

尽管JavaScript有许多强大的函数式特征，但更重要的是了解到它既是面向对象的，也是函数式的。然而，后者鲜有人知。大多数开发人员都在使用可变的操作、命令式的控制结构以及对实例对象状态的改变，而这些都是在函数式风格的代码中需要尽可能避免的行为。不过，我还是觉得应该花一些时间先谈谈作为一种面向对象语言的 JavaScript，从而更好地区分两种范式之间的关键差异。这将让你更轻松地跃入函数式编程。

2.2　函数式与面向对象的程序设计

无论是函数式还是面向对象编程（OOP）都可以用来开发中到大型的软件系统。诸如Scala和F#这样的混合语言能够将两种范式融入一种语言。JavaScript也具有类似的能力，因此要精通它需要学习如何将二者结合在一起，也要学会根据个人喜好和待解决问题的需求在二者之间寻求平衡。了解函数式和面向对象方案的共性及差异可以帮助你从一种范式过渡到另一种范式，或用任意一种范式来思考。

考虑一个简单的涉及Student 对象的学习管理系统模型。从类或类型层次的角度来看，我们能够很自然地想到 Student 应该作为 Person 的一个子类型，其中包括像姓、名、地址等基本属性。

面向对象的 JavaScript

当说到一个对象与另一个对象之间具有子类型或派生类型的关系时，指的是它们之间存在的原型关系。有必要指出，尽管 JavaScript 是面向对象的，但其并不具备像 Java 这样的语言中典型的继承关系。

在ES6中，可以通过使用像关键字class 和extends 这样的语法糖来建立对象之间的原型链接（尽管很多情况下这样做是不对的）。这样的特性使得定义对象之间的继承更加简单，但却隐藏了 JavaScript 强大的原型机制的真实行为。本书将不过多介绍 JavaScript 的面向对象编程（本章的最后将推荐一本深入讨论该话题的书）。

如果进一步将 Student 派生为更具体的类型，例如CollegeStudent ，就可以再添加一些额外的功能。面向对象的核心，就是将创建派生对象作为程序中代码重用的主要手段。因此，CollegeStudent 将会重用从其父类继承而来的所有数据与行为。但这使得在原对象中添加更多功能变得很棘手，因为它的后代们并不一定会适用于这些新功能。虽然 firstname 和 lastname 适用于 Person 及其所有的子类型，但可以说让 workAddress 作为（从 Person 派生的）Employee 对象的一部分比起 Student 对象要更合理一些。之所以举这样的例子，是为了解释在数据（对象属性）与行为（函数）的组织上，面向对象和函数式的主要差别。

面向对象的应用程序大多是命令式的，因此在很大程度上依赖于使用基于对象的封装来保护其自身和继承的可变状态的完整性，再通过实例方法来暴露或修改这些状态。其结果是，对象的数据与其具体的行为以一种内聚的包裹的形式紧耦合在一起。而这就是面向对象程序的目的，也正解释了为什么对象是抽象的核心。

再看函数式编程，它不需要对调用者隐藏数据，通常使用一些更小且非常简单的数据类型。由于一切都是不可变的，对象都是可以直接拿来使用的，而且是通过定义在对象作用域外的函数来实现的。换句话说，数据与行为是松耦合的。正如在图2.1中看到的，函数式代码使用的是可以横切或工作于多种数据类型之上的更加粗粒度的操作，而不是一些细粒度的实例方法。在这种范式中，函数成为抽象的主要形式 。

图2.1　面向对象的程序设计通过特定的行为将很多数据类型逻辑地连接在一起，函数式编程则关注如何在这些数据类型之上通过组合来连接各种操作。因此存在一个两种编程范式都可以被有效利用的平衡点。使用如Scala、F#和JavaScript这样的混合语言就可以这么做

如图2.1所示，两种范式的差别随着横竖坐标的增长逐渐显现。在实践中，一些极好的面向对象代码均使用了两种编程范式——正是在这个相交的平衡点上。要做到这一点，你需要把对象视为不可变的实体或值，并将它们的功能拆分成可应用在该对象上的函数。因此，如下的一个Person 中的方法

get fullname() {
   return [this._firstname, this._lastname].join(' ');  <---比如在方法中，会推荐使用this来访问对象的状态
}

可以拆分出如下的函数：

var fullname =
   person => [person.firstname, person.lastname].join(' ');  <---函数中this可以替换为传入的参数对象

众所周知，JavaScript是一种动态类型语言（也就是无须在对象引用时显示指定类型），因此fullname() 可以适用于任何派生自Person 的对象（其实是任何拥有 firstname 和lastname 属性的对象），如图2.2所示。

图2.2　面向对象的关键是创建继承层次结构（如继承Person 的Student 对象）并将方法与数据紧密的绑定在一起。函数式编程则更倾向于通过广义的多态函数交叉应用于不同的数据类型，同时避免使用this

鉴于 JavaScript 的动态特性，其支持使用广义的多态函数。换句话说，使用基类引用的函数（如Person ）也能应用在派生类型的对象上（如Student 或CollegeStudent ）。

从图2.2中可以看出，将fullname() 分离至独立的函数，可以避免使用 this 引用来访问对象数据。使用this 的缺点是它给予了超出方法作用域的实例层级的数据访问能力，从而可能导致副作用。使用函数式编程，对象数据不再与代码的特定部分紧密耦合，从而更具重用性和可维护性。

可以通过将其他函数作为参数的形式（而不是通过创建一堆的派生类型）来扩展当前函数的行为。为了说明这一点，我们在下面定义一个简单的数据模型，其中包含由 Person 类派生而来的类 Student 。本书的大部分例子都采用了这个模型，如清单2.1所示。

清单 2.1　Person 类与 Student 类的定义

class Person {
   constructor(firstname, lastname, ssn) {
      this._firstname = firstname;
      this._lastname = lastname;
      this._ssn = ssn;
      this._address = null;
      this._birthYear = null;
   }

   get ssn() {
       return this._ssn;
   }

   get firstname() {
       return this._firstname;
   }

   get lastname() {
      return this._lastname;
   }

   get address() {
      return this._address;
   }

   get birthYear() {
      return this._birthYear;
   }
   set birthYear(year) { <---使用setter方法并不代表要改变对象，而只是创建含有不同属性的对象，而且无需长参数构造函数的方式。在创建并设置好对象后，它们的状态将不会改变（本章之后的部分会解释处理方式）
      this._birthYear = year;
   }

   set address(addr){ <---使用setter方法并不代表要改变对象，而只是创建含有不同属性的对象，而且无需长参数构造函数的方式。在创建并设置好对象后，它们的状态将不会改变（本章之后的部分会解释处理方式）
      this._address = addr;
   }

   toString() {
      return `Person(${this._firstname}, ${this._lastname})`;
   }
}

class Student extends Person {
   constructor(firstname, lastname, ssn, school) {
      super(firstname, lastname, ssn);
      this._school = school;
   }

   get school() {
      return this._school;
   }
}

寻找并运行代码示例

本书的代码示例可以在www.manning.com/books/functional-programming-in-javascript和 https://github.com/luijar/functional-programming-js 找到。你可以随时找出这些项目代码，并开始练习函数式编程。我建议你先运行一下单元测试，然后再使用不同的程序实现去通过它。在写这本书的时候，并非所有的 JavaScript ES6 特性都已在各个浏览器中实现，因此我用 Babel（以前叫 6to5）转译器将 ES6 的代码转换成等效的 ES5 代码。

还有一些特性并不需要转换，只需开启如 Chrome 的“启用实验性 JavaScript”这样的浏览器设置就可以了。如果你正运行在试验模式，非常重要的一点是，要启用严格模式，请将 ‘use strict’ ；这段声明代码放在 JavaScript 文件的开头。

目前的一个任务是找到与给定的学生生活在同一国家的所有朋友。另一个任务则是找到与给定的学生生活在同一个国家且在同一所学校上学的所有学生。以下面向对象的解决方案中，使用this 和super 将各种操作与当前对象以及父对象紧紧地耦合在一起：

// Person class
peopleInSameCountry(friends) {
    var result = [];
    for (let idx in friends) {
        var friend = friends [idx];
        if (this.address.country === friend.address.country) {
            result.push(friend);
        }
    }
    return result;
};

// Student class
studentsInSameCountryAndSchool(friends) {
    var closeFriends = super.peopleInSameCountry(friends);  <---使用super调用父类的数据
    var result = [];
    for (let idx in closeFriends) {
        var friend = closeFriends[idx];
        if (friend.school === this.school) {
            result.push(friend);
        }
    }
    return result;
};

然而，由于函数式编程是纯的且引用透明，通过从状态中分离行为的方式，我们可以使用定义和组合新函数的办法来增加更多可以用于目标类型的操作。而这样，最终只会有一些负责存储数据的简单对象，以及数个以这些对象为参数且可组合实现特定功能的通用函数。尽管目前我们还没有介绍函数式的组合（见第4章），但了解编程范式之间的这些基本区别是非常重要的。从本质上讲，面向对象的继承和函数式中的组合都是为了将新的行为应用于不同的数据类型当中[ 1] 。若要运行此代码，则需要使用以下数据集：

var curry = new Student('Haskell', 'Curry',
     '111-11-1111', 'Penn State');
curry.address = new Address('US');

var turing = new Student('Alan', 'Turing',
     '222-22-2222', 'Princeton');
turing.address = new Address('England');

var church = new Student('Alonzo', 'Church',
   '333-33-3333', 'Princeton');
church.address = new Address('US');

var kleene = new Student('Stephen', 'Kleene',
   '444-44-4444', 'Princeton');
kleene.address = new Address('US');

面向对象方法使用 Strudent 上的成员方法来找出同一所学校的所有其他学生：

church.studentsInSameCountryAndSchool([curry, turing, kleene]);
//-> [kleene]

函数式的解决方案则将问题分解为很多小的函数：

function selector(country, school) { <---创建selector函数，用来比较学生的国籍与学校
   return function(student) {
      return student.address.country() === country && <---访问对象。我会在本章后面的部分展示访问对象的更好方式
         student.school() === school;
      };
}
　
var findStudentsBy = function(friends, selector) { <---使用filter用selector过滤数组
    return friends.filter(selector);
};
　
findStudentsBy([curry, turing, church, kleene],
  selector('US', 'Princeton'));
　
//-> [church, kleene]

通过应用函数式思想，我们创建了一个更易于应用的全新函数find-StudentsBy 。请注意，这个新的函数对任何由Person 衍生的对象有效，同时支持任意学校和国家的组合查询。

这一点清楚地表明了两种模式之间的差异。面向对象的设计着重于数据及数据之间的关系，函数式编程则关注于操作如何执行，即行为。表2.1汇总了其他值得关注的主要区别，这些点将在本章和后续章节深入讨论。

表2.1　　面向对象和函数式编程一些重要性质的比较。这些性质是贯穿本书的主题

尽管它们之间存在差异，但有效构建应用程序的方法是混合两种范式。一方面，可以使用与组成类型之间存在自然关系的富领域模型；另一方面，可以拥有一组能够应用于这些类型之上的纯函数。其中界限的确定取决于代码编写者是否对任一编程范式应用自如。由于 JavaScript 既是面向对象的，又是函数式的，因此在编写函数式代码时，需要特别注意控制状态的变化。

2.2.1　管理JavaScript对象的状态

程序的状态 可以定义为在任一时刻存储在所有对象之中的数据快照。可惜的是，JavaScript 是在对象状态安全方面做得最差的语言之一。JavaScript 的对象是高度动态的，其属性可以在任何时间被修改、增加或删除。在清单2.1中，如果期望 _address （下划线的使用是纯句法的）被封装于 Person 之内，那么就大错特错了。在类型作用域之外，开发者拥有对该属性的完全访问权限来执行任何想做的操作，甚至是将其删除。

自由的代价是重大的责任。尽管这会让你自由地去做一些如动态创建属性这样的灵活的事情，但在中大型项目中，这也会使得代码极难维护。

第1章提到，使用纯函数会使代码更易于维护和推理。那么是否存在“纯对象”这种事物呢？可以认为一个包含不可变功能的不可变对象是纯的。相应地，可应用于函数的推理过程也可以应用于简单对象。在寻求函数式地使用 JavaScript 语言的过程中，状态管理至关重要。尽管后续章节探讨了一些可以用来管理不可变性的实践与模式，但完整的数据封装和保护将在实践道路上占很大比重。

2.2.2　将对象视为数值

字符串和数字可能是任何编程语言中最简单的数据类型了。那为什么会这样认为呢？部分原因在于，在传统意义上，这些原始类型本身就是不可变的，而这给我们的内心带来了其他自定义类型所无法给予的平和。在函数式编程中，我们将具有此种行为的类型称为数值 。在第1章中，我们学到，要做到不可变的思考，就需要将任何对象视为数值。而这样做可以让函数将对象传来传去，而不用担心它们被篡改。

虽然 ES6 在类上添加了很多语法糖，但 JavaScript 的对象也只是可在任意时间添加、删除和更改的属性包而已。那么，能做些什么来解决这个问题呢？许多编程语言支持让对象属性不可变的语法结构。其中一个例子就是 Java 的final 关键字。同时，像 F# 这样的语言，除非特别声明，否则其变量默认就是不可变的。但是到目前为止，JavaScript 中还没有如此炫酷的语言特性。尽管 JavaScript 的原始类型是不能改变的，但引用原始类型的变量状态是可以被更改的。因此，提供或者至少模拟对数据的不可变引用，才能使得自定义对象具有近似不可变的行为。

ES6 使用const 关键字来创建常量引用。这确实指对了方向，因为常量是不能被重新赋值或声明的。在实践函数式编程时，如果需要，可以使用 const 关键字来声明一些简单的配置数据（URL字符串、数据库名称等）。尽管读取外部变量会有副作用，但由于语言平台提供了这种具有特殊语义的常量，因此它们不会在函数调用之间被篡改。下面是声明一个常量的例子：

const gravity_ms = 9.806;

gravity_ms = 20;  <--- JavaScript会在运行时阻止再赋值

但仅仅如此并不能达到函数式编程所需要的不可变性的支持水平。你可以防止一个变量被重新赋值，但如何防止对象内部状态的改变呢？比如以下代码是完全可以通过的：

const student = new Student('Alonzo', 'Church',
   '666-66-6666', 'Princeton');

student.lastname = 'Mourning';  <---属性已经变了

这里需要的是一个更加严格的不可变策略，而封装是一个防止篡改的不错策略。对于一些简单的对象结构，一个好的方法是采用值对象 模式。值对象是指其相等性不依赖于标识或引用，而只基于其值，一旦声明，其状态可能不会再改变。除了数字和字符串，值对象的一些实例还包括tuple 、pair 、point 、zipCode 、coordinate 、money 、date 以及其他类型。以下是一个邮编的实现代码：

function zipCode(code, location) {
   let _code = code;
   let _location = location || '';

   return {
      code: function () {
         return _code;
      },
      location: function () {
         return _location;
      },
      fromString: function (str) {
         let parts = str.split('-');
         return zipCode(parts[0], parts[1]);
      },
      toString: function () {
         return _code + '-' + _location;
      }
   };
}

const princetonZip = zipCode('08544', '3345');
princetonZip.toString(); //-> '08544-3345'

在 JavaScript 中，可以使用函数来保障 ZIP code 的内部状态访问权限，通过返回一个对象字面接口 来公开一小部分方法给调用者，这样就可以将_code 和_location 视为伪私有变量。在后续章节中能够看到，这些变量只能通过闭包的方式由对象的字面定义中访问。

返回的对象可以表现出像原始类型一样没有可变方法的行为。因此[ 2] ，尽管toString 方法不是纯函数，但其行为与纯函数无异，就是该对象的纯字符串表示。值对象是一种可简单应用于面向对象和函数式编程的轻量级方式。与关键字const 组合在一起使用，我们就可以创建具有与字符串或数字类似语义的对象。下面来看一个例子：

function coordinate(lat, long) {
   let _lat = lat;
   let _long = long;

   return {
      latitude: function () {
         return _lat;
      },
      longitude: function () {
         return _long;
     },
      translate: function (dx, dy) {
         return coordinate(_lat + dx, _long + dy);  <---返回翻译过的坐标副本
      },
      toString: function () {
         return '(' + _lat + ',' + _long + ')';
      }
   };
}
const greenwich = coordinate(51.4778, 0.0015);
greenwich.toString(); //-> '(51.4778, 0.0015)'

让方法返回一个新的副本（例如 translate ）是另一种实现不可变性的方式。在该对象上应用一次平移操作，将产生一个新的 coordinate 对象：

greenwich.translate(10, 10).toString(); //-> '(61.4778, 10.0015)'

值对象是一个由函数式编程启发而来的面向对象设计模式。这是语言范式之间如何优雅地相得益彰的另一个例子。这种模式是理想的，但无法解决所有的现实世界问题。在实践中，代码很可能需要处理层次化数据（例如之前的 Person 和 Student ），也可能需要和历史遗留对象进行交互。幸运的是，JavaScript 可以使用 Object.freeze 机制来模拟这些问题。

2.2.3　深冻结可变部分

尽管 JavaScript 新的类定义语法中不存在能够将字段标记为不可变量的关键字，但它拥有一种内部机制，可以通过控制一些如 writable 的隐藏对象元属性来实现。JavaScript 的 Object.freeze() 函数可以通过将该属性设置为 false 来阻止对象状态的改变。让我们冻结 Person 对象，如清单2.1所示：

var person = Object.freeze(new Person('Haskell', 'Curry', '444-44-4444'));
person.firstname = 'Bob';  <---不被允许

执行第一行代码使得 person 的属性变成只读。任何试图改变其值的操作（如 _firstname 这一行）将导致错误：

TypeError: Cannot assign to read only property '_firstname' of #<Person>

Object.freeze() 也可以冻结继承而来的属性。因此，也可以用同样的方式冻结Student 的实例，该机制会根据对象的原型链保护所有由 Person 继承而来的属性。但是，它不能被用于冻结嵌套对象属性，如图2.3所示。

图2.3　尽管 Person 已被冻结，但其内部对象属性（如_address ）并不会被冻结，因此 person.address.country 可以随时改变。这是由于只有顶层变量会被冻结，也就是说，该机制是浅冻结

Address 类型的定义如下：

class Address {
   constructor(country, state, city, zip, street) {
     this._country = country;
     this._state = state;
     this._city = city;
     this._zip = zip;
     this._street = street;
   }

   get street() {
      return this._street;
   }

   get city() {
      return this._city;
   }

   get state() {
      return this._state;
   }

   get zip() {
      return this._zip;
   }

   get country() {
      return this._country;
   }
}

然而，以下代码并不会报错：

var person = new Person('Haskell', 'Curry', '444-44-4444');
person.address = new Address(
    'US', 'NJ', 'Princeton',
     zipCode('08544','1234'), 'Alexander St.');

    person = Object.freeze(person);

person.address._country = 'France'; //-> allowed!
person.address.country; //-> 'France'

Object.freeze() 是一种浅操作。要解决该问题，需要手动冻结对象的嵌套结构，如清单2.2所示。

清单2.2　使用递归函数来深冻结对象

var isObject = (val) => val && typeof val === 'object';

   function deepFreeze(obj) {
    if(isObject(obj)  <---遍历所有属性并递归调用Object.freeze()（使用第3章介绍的map）
      && !Object.isFrozen(obj)) { <---跳过已经冻结过的对象，冻结没有被冻结过的对象

        Object.keys(obj).  <---跳过所有的函数，即使从技术上说，函数也可以被修改，但是我们更希望注意在数据的属性上
            forEach(name => deepFreeze(obj[name]));  <---递归地自调用（第3章会介绍递归）

        Object.freeze(obj);  <---冻结根对象
    }
    return obj;
   }

上述的一些技巧可以用来增强代码中的不可变性水平，但要创建一个永不改变任何状态的应用是不现实的。因此，在由原对象创建新对象（如coordinate.translate() ）时，使用这些严格的策略能够有效降低JavaScript应用的复杂性。接下来，我们将讨论使用一种称为Lenses的函数式方法来不可变地集中管理对象的变化。

2.2.4　使用Lenses定位并修改对象图

面向对象编程通常是通过调用对象方法来更改对象的内部状态的。这种方式的缺点是无法保证检索状态的输出一致，并可能破坏部分的期望该对象保持不变的系统功能。你也可以选择自行实现写时复制 策略，在每次方法调用时返回一个新的对象。但至少可以说，这是一个烦琐且容易出错的过程。Person 类的简单setter方法会是这样的：

set lastname(lastname) {
    return new Person(this._firstname, lastname, this._ssn);  <---需要将对象中所有的属性状态复制到新的实例（太糟糕了）
};

现在想象一下，在领域模型中，每个类型的每个属性都要做同样的事。开发者需要一个能以不可变的方式修改拥有状态对象的解决方案，它应该既不唐突，也不需要到处都硬编码同样的样板代码。Lenses也被称为函数式引用 ，是函数式程序设计中用于访问和不可改变地操纵状态数据类型属性的解决方案。从本质上讲，Lenses 与写时复制策略的工作方式类似，即采用一个能够合理管理和赋值状态的内部存储部件。然而，开发者不需要自行实现，而是可以使用一个称为 Ramda.js 的函数式 JavaScript 库（附录中包含使用该库以及其他库的详细信息）。默认情况下，Ramda 使用全局对象 R 来公开所有的功能。可以使用 R.lensProp 来创建一个包装了Person 的 lastname 属性的 Lens：

var person = new Person('Alonzo', 'Church', '444-44-4444');
var lastnameLens = R.lenseProp('lastName');

可以使用R.view 来读取该属性的内容：

R.view(lastnameLens, person); //-> 'Church'

从实践角度看，它类似于一个 get_lastname() 方法。目前还没有什么令人印象深刻的东西。那么，如何实现setter 呢？这里就是其神奇魔力的所在。调用R.set 时，它创建并返回一个全新的对象副本，其中包含一个新的属性值，并保留原始实例状态（免费的写时复制！）：

var newPerson = R.set(lastnameLens, 'Mourning', person);
newPerson.lastname; //-> 'Mourning'
person.lastname; //-> 'Church'

Lenses 之所以有价值，是因为其提供了一种不那么烦琐的操作对象的机制，即使是一些历史遗留对象或超出控制范围的对象。Lenses 还支持嵌套属性，如 Person 的 address 属性：

person.address = new Address(
   'US', 'NJ', 'Princeton', zipCode('08544','1234'),
   'Alexander St.');

创建一个包装了 address.zip 属性的 Lens：

var zipPath = ['address', 'zip'];
var zipLens = R.lens(R.path(zipPath), R.assocPath(zipPath));  <---定义getter和setter行为
R.view(zipLens, person); //-> zipCode('08544', '1234')

由于 Lenses 实现了不可变的 setter 方法，因此即便改变内嵌对象，仍然会返回一个新的 Person 对象：

var newPerson = R.set(zipLens, person, zipCode('90210', '5678'));

R.view(zipLens, newPerson); //-> zipCode('90210', '5678')
R.view(zipLens, person);    //-> zipCode('08544', '1234')
newPerson !== person; //-> true

这是个不错的进展，现在已经有了函数式getter和setter的语义了。除了提供一种不可变的保护性的包装器之外，Lenses 也与函数式编程的分离对象与字段访问逻辑的哲学思想非常契合，即消除了对this 的依赖，并提供了很多能够操作对象内容的强大函数。

既然已经知道该如何合理地使用对象了，我将转变方式来谈谈函数这一主题。函数驱动着应用程序的变化部分，它是函数式编程的核心。

2.3　函数

函数是函数式编程的工作单元与中心。函数 是任何可调用且可通过() 操作求值的表达式。函数会向调用者返回一个经过计算的值或是 undefined （无值函数）。函数式程序的工作方式与数学很像，函数只有在返回一个有价值的结果 （而不是 null 或者 undefined ）时才有意义。反之，它就会更改外部数据并产生副作用。为了达到学习目的，我们需要区分表达式 （如返回一个值的函数）和语句 （如不返回值的函数）。命令式编程和过程式程序大多是由一系列有序的语句组成的，而函数式编程完全依赖于表达式，因此无值函数在该范式下并没有意义。

JavaScript 函数有两个支柱性的重要特性：一等的和高阶的。我们接下来会详细探讨这两个特性。

2.3.1　一等函数

在JavaScript中，术语是一等的 ，指的在语言层面将函数视为真实的对象。或许读者经常看到如下的函数声明：

function multiplier(a,b) {
   return a * b;
}

其实，JavaScript提供了更多的方式。就像对象一样，函数也可以：

• 作为匿名函数或lambda表达式给变量赋值（第3章将详细介绍lambda）。

var square = function (x) { <---匿名函数
   return x * x;
}

var square = x => x * x;  <--- lambda表达式

• 作为成员方法给对象的属性赋值。

var obj = {
   method: function (x) { return x * x; }
};

由于需要使用() 运算符调用函数，如square(2) ，因此可以像如下代码一样打印出函数对象：

square;
// function (x) {
//    return x * x;
// }

函数还可以通过构造函数来实例化，尽管这并不常见，但它能够证明其在JavaScript 中的一等性。构造函数以函数形参，函数体为参数，并需要使用new 关键字，如：

var multiplier = new Function('a', 'b', 'return a * b');

multiplier(2, 3); //-> 6

在 JavaScript 中，任何函数都是 Function 类型的一个实例。函数的 length 属性可以用来获取形参的数量，而像apply() 和call() 方法可以用来调用函数并加入上下文（更多相关知识将在下一节讨论）。

匿名函数表达式的右侧是一个具有空 name 属性的函数对象。可以通过将匿名函数作为参数的方式来扩展或者定制化当前函数的行为。JavaScript 原生的 Array.sort(comparator) 就需要一个函数对象作为比较器。默认情况下，sort 会将值转换为字符串，再利用其 Unicode 值进行自然排序。但这往往不是我们期望的行为。下面来看几个例子：

var fruit = ['Coconut', 'apples'];
fruit.sort(); //->['Coconut', 'apples']  <---大写字母的unicode编码会在小写字母之后

var ages = [1, 10, 21, 2];
ages.sort(); //->[1, 10, 2, 21]  <---数组会被转换成字符串，并比较unicode编码

其实，sort() 通常需要一个预定义的comparator 函数来驱动其行为，其本身用处并不大。可以使用一个自定义函数参数来实现按名单人员年龄的数字大小排序：

people.sort((p1, p2) => p1.getAge() - p2.getAge());

该comparator 函数的两个参数p1 和p2 具有以下约束。

• 如果comparator 的返回值小于0，p1 应在p2 之前。
• 如果comparator 返回0，p1 与p2 的顺序不变。
• 如果comparator 的返回值大于0，p1 应在p2 之后。

像sort() 这样可以接收其他函数作为参数的JavaScript函数，均属于一种函数类型——高阶函数 。

2.3.2　高阶函数

鉴于函数的行为与普通对象类似，其理所当然地可以作为其他函数的参数进行传递，或是由其他函数返回。这些函数则称为高阶函数 。目前我们已经看到了 Array.sort() 的comparator函数，让我们再来快速浏览其他一些例子。

下面的代码片段显示函数是可以传入其他函数中的。其中的 applyOperation 函数可以将任意的opt 函数应用于前两个参数：

function applyOperation(a, b, opt) { <--- opt()函数可以作为参数传入其他函数中
   return opt(a,b);
}

var multiplier = (a, b) => a * b;

applyOperation(2, 3, multiplier); // -> 6

在下面的例子中，add 函数接收一个参数，并返回另一个接收第二个参数并把它们加在一起的函数：

function add(a) {
  return function (b) { <---一个返回其他函数的函数
      return a + b;
  }
}
add(3)(3); //-> 6

因为函数的一等性和高阶性，JavaScript 函数具有值的行为 ，也就是说，函数就是一个基于输入的且尚未求值的不可变的值。这一原则将贯穿整个函数式编程的学习，尤其体现在第3章将要介绍的函数链的内容中。函数链的建立基于一些指向不同代码片段的函数名，它们将作为整个表达式的各部分被执行。

通过组合一些小的高阶函数来创建有意义的表达式，可以简化很多烦琐的程序。例如，假设需要打印住在美国的人员名单。一开始的实现很可能是这样的命令式代码：

function printPeopleInTheUs(people) {
   for (let i = 0; i < people.length; i++) {
     var thisPerson = people[i];
     if(thisPerson.address.country === 'US') {
       console.log(thisPerson);  <---隐式调用对象的toString方法
    }
 }
}
printPeopleInTheUs([p1, p2, p3]);  <--- p1、p2和p3 是Person的实例

现在假设还需要支持打印生活在其他国家的人。通过高阶函数，我们可以很好地抽象出应用于每个人的操作，这里就是控制台的打印逻辑。可以给高阶函数 printPeople 提供任何 action 函数：

function printPeople(people, action) {
   for (let i = 0; i < people.length; i++) {
      action (people[i]);
   }
}

var action = function (person) {
   if(person.address.country === 'US') {
      console.log(person);
   }
}

printPeople(people,action);

JavaScript 语言中显著的命名模式之一是使用如 multiplier 、comparator 以及 action 这样的受事名词。这也是因为这些函数是一等的，可以给变量赋值，并在之后再执行。基于函数的高阶特性将 printPeople 重构一下：

function printPeople(people, selector, printer) {
   people.forEach(function (person) { <--- forEach是函数式推荐的循环方式。本章之后的部分讨论这个话题
      if(selector(person)) {
         printer(person);
      }
   });
}

var inUs = person => person.address.country === 'US';

printPeople(people, inUs, console.log);  <---通过使用高阶函数，开始呈现出声明式的模式。表达式清晰地描述了程序需要做的事情

它需要一个完全拥抱函数式编程的心态。而从上例可以看出，这段代码可以变得比一开始灵活得多，因为现在可以轻松地改变选择条件以及打印的方式。第3章和第4章将紧紧围绕这个主题，使用一些特殊的库将一些简单的操作流式地链接在一起，来构建复杂的程序。

展望未来

这里笔者想暂停一下对核心 JavaScript 内容的讨论，结合一些已经简单介绍过的概念，进一步地讨论本节的程序。尽管对于现在来说，这是有点高级的技巧，但是很快，读者就会了解如何通过这种方式使用函数式编程来构建程序。可以使用 Lens 来创建可以访问对象属性的函数：

var countryPath = ['address', 'country'];
var countryL = R.lens(R.path(countryPath), R.assocPath(countryPath));
var inCountry = R.curry((country, person) =>
        R.equals(R.view(countryL, person), country));

这样的代码比之前的更加函数式了：

people.filter(inCountry('US')).map(console.log);

如上述代码所示，国家名变成另一个可以是任意值的参数。这个值得期待的特性将在后续章节中介绍。

在JavaScript中，函数不仅能够被调用，还可以被应用。下面介绍JavaScript的函数调用机制这一特质。

2.3.3　函数调用的类型

JavaScript 的函数调用机制与其他语言的不同，是语言中一个十分有趣的部分。JavaScript 给予了我们完全的自由来指定调用函数的运行上下文，也就是函数体中 this 的值。因此，JavaScript 的函数可以使用许多不同的方式来调用。

• 作为全局函数 ——其中this 的引用可以是global 对象或是undefined （在严格模式中）:

function doWork() {
   this.myVar = 'Some value';  <---在全局上下文调用doWork()会造成this引用到全局对象上
}
doWork();  <---在全局上下文调用doWork()会造成this引用到全局对象上

• 作为方法 ——其中 this 的引用是方法的所有者。这是 JavaScript 的面向对象特性的重要部分：

var obj = {
    prop: 'Some property', 
    getProp: function () {return this.prop} <---调用对象中的方法时，this指向该对象
};
obj.getProp(); <---调用对象中的方法时，this指向该对象

• 作为构造函数与 new 一起使用 ——这种方式会返回新创建对象的引用：

function MyType(arg) {
   this.prop = arg; <---使用new关键字会把this引用到新创建的对象上
}

var someVal = new MyType('some argument'); <---使用new关键字会把this引用到新创建的对象上

正如从例子中看到的，不同于其他编程语言，this 的引用取决于函数式如何使用的（如全局的、或是作为对象方法、或是作为构造函数等），而不是取决于函数体中的代码。由于需要特别关注函数是如何被执行的，因此这会导致代码难于理解。

作为一个 JavaScript 开发，了解这些内容是非常重要的，但正如上文不断指出的，在函数式代码中很少会使用this （事实上，应不惜一切代价来避免使用它）。但在一些库和工具中，它被大量使用，以在一些特殊情形下改变语言环境来实现一些难以置信的功能。这些往往会涉及 apply 方法以及 call 方法。

2.3.4　函数方法

JavaScript 支持通过使用函数原型链上的函数方法（类似元函数）call 和 apply 来调用函数本身。两个函数方法都广泛应用于脚手架代码的构建中，这样 API 用户就可以通过现有的函数去创建新的函数。下面来看如何写一个 negate 函数：

function negate(func) { <---高阶函数negate接收一个函数作为输入，并返回取反其结果的函数
   return function() {
      return !func.apply(null, arguments);  <---使用fun.apply()来使用原来的参数调用函数
   };
}

function isNull(val) { <---定义isNull函数
   return val === null;
}

var isNotNull = negate(isNull);  <---定义isNull函数的反，即isNotNull函数

isNotNull(null); //-> false
isNotNull({});   //-> true

该 negate 函数创建了一个新的函数，它会调用其参数，再取结果的倒数。上例使用了 apply 方法，但也可以使用 call 函数。不同之处在于前者接收一个参数组成的数组，而后者接收参数列表。第一个参数 thisArg 可用于按需修改函数的上下文。它们的函数签名如下：

Function.prototype.apply(thisArg, [argsArray])

Function.prototype.call(thisArg, arg1,arg2,...)

如果 thisArg 是一个对象，它表示该函数将作为该对象的成员方法被调用。如果 thisArg 为 null ，则表示该函数的上下文为全局对象，该函数的行为就像一个全局函数。但是，如果该方法是严格模式下定义的函数，null 才是实际被传入的值。

通过 thisArg 修改函数上下文可以灵活地应用在许多不同的技术中。但函数式编程并不鼓励这样，因为它永远不会依赖于函数的上下文状态（前面讲过，所有的数据都应以参数的形式提供给函数），所以我们不再过多讨论该功能。

尽管全局共享以及对象上下文的概念在函数式JavaScript编程中没太大用处，但有一个特殊的上下文概念我们应当注意，即函数上下文。要了解它，必须先理解闭包和作用域。

2.4　闭包和作用域

在 JavaScript 出现之前，闭包只存在于函数式编程语言中，用于编写某些特殊的应用程序。JavaScript 是第一个在主流开发中应用闭包的语言，显著地改变了开发者编写代码的方式。再重温一下 zipCode 这个类型：

function zipCode(code, location) {
    let _code = code;
    let _location = location || '';

    return {
       code: function () {
         return _code;
       },
       location: function () {
          return _location;
       },
     ...
   };
}

如果仔细观察这段代码，就会发现，zipCode 函数返回的对象似乎能够完全访问其作用域之外声明的变量。也就是说，zipCode 执行完毕后，生成的对象仍然可以看到在这个封闭函数中声明的信息：

const princetonZip = zipCode('08544', '3345');
princetonZip.code(); //-> '08544'

这有点难以想象，都归功于在 JavaScript 中形成于对象和函数声明周围的闭包。能够这样访问数据具有很好的实用价值，我们在本节中将会看到如何使用闭包来模拟私有成员变量、如何从服务器获取数据以及创建块作用域变量。

闭包 是一种能够在函数声明过程中将环境信息与所属函数绑定在一起的数据结构。它是基于函数声明的文本位置的，因此也被称为围绕函数定义的静态作用域 或词法作用域 。闭包能够使函数访问其环境状态，使得代码更清晰可读。你很快就会看到，闭包不仅应用于函数式编程的高阶函数中，也可用于事件处理和回调、模拟私有成员变量，还能用于弥补一些 JavaScript 的不足。

支配函数闭包行为的规则与 JavaScript 的作用域规则密切相关。作用域能够将一组变量绑定，并定义变量定义的代码段。从本质上讲，闭包就是函数继承而来的作用域，这类似于对象方法是如何访问其继承的实例变量的，它们都具有其父类型的引用。在内嵌函数中能够很清楚地看到闭包，示例如下：

function makeAddFunction(amount) {
  function add(number) { <--- add函数可以通过词法绑定访问到amount变量
      return number + amount;
   }
   return add;
}

function makeExponentialFunction(base) {
   function raise (exponent) { <--- raise()函数也可以通过词法绑定访问到base
     return Math.pow(base, exponent);
   }
   return raise;
}
var addTenTo = makeAddFunction(10);
addTenTo(10); //-> 20

var raiseThreeTo = makeExponentialFunction(3);
raiseThreeTo(2); //-> 9

值得注意的是，尽管两个函数中的变量amount 和base 并不在返回函数的活动作用域中，但通过调用返回函数仍然可以访问它们。从本质上讲，可以想象内嵌函数add 和raise 在声明式中不仅包含其计算逻辑，也包含其周围所有变量的快照。更一般地，如图2.4所示，函数的闭包包括以下内容。

图2.4　闭包包含了在外部（全局）作用域中声明的变量、在父函数内部作用域中声明的变量、父函数的参数以及在函数声明之后声明的变量。函数体中的代码可以访问这些作用域中定义的变量和对象。而所有函数都共享全局作用域

• 函数的所有参数（在本例中是 params 和 params2 ）。
• 外部作用域的所有变量（当然也包括所有的全局变量），包括那些如 additional Vars 这样在函数后声明的变量。

再看一个真实代码中闭包的例子，如清单2.3所示。

清单 2.3　真实代码中的闭包

var outerVar = 'Outer';  <---声明全局变量outerVar
function makeInner(params) {
  var innerVar = 'Inner';  <---调用makeInner会得到inner函数
  function inner() {
      console.log( <---声明inner：innerVar和outerVar在inner闭包内
       `I can see: ${outerVar}, ${innerVar}, and ${params}`);
   }
   return inner;
}

var inner = makeInner('Params'); <---声明局部变量makeInner
inner(); <---函数inner生命周期比外部函数还长

运行此代码会打印出如下输出：

'I can see: Outer, Inner, and Params'

乍看起来，这似乎并不直观，还有点神秘。这个局部变量 innerVar 应该不复存在，或者在 makeInner 返回后被垃圾回收，从而打印出 undefined 。其实，这正是闭包的神奇之处。从 makeInner 返回的函数会在其声明时记住其作用域内的所有变量，并防止它们被回收。由于全局作用域内也是闭包的一部分，因此返回的函数也能够访问 outerVar 。第7章将继续闭包以及函数上下文的内容的讨论。

或许读者想知道为什么函数声明之后声明的变量（如 additionalVars ）也可以作为闭包的一部分。要回答这个问题，读者需要明白 JavaScript 的3种类型的作用域：全局作用域、函数作用域以及伪块作用域。

2.4.1　全局作用域

全局作用域是最简单的作用域，但也是最差的。任何对象和在脚本最外层声明的（不在任何函数中的）变量都是全局作用域 的一部分，并且可以被所有 JavaScript 代码访问。函数式编程的目的是为了防止任何可被观测的变化影响到函数之外的部分，然而在全局作用域内，每执行一行都会导致明显变化。

尽管使用全局变量很容易，但是它们会被所有加载到页面中的脚本所共享。如果 JavaScript 代码不是以模块打包的，那么这样很容易导致命名空间冲突。全局命名空间的污染会导致很多问题，很容易导致不同文件中定义的变量和函数被重写。

全局数据也会使得程序难以推理，因为你需要时刻谨记所有的变量。这也是为什么随着代码量的增加，程序越来越复杂的原因之一。全局数据也会引发副作用，因为在读取或写入时，会不可避免地形成外部依赖。由此显而易见，在函数式编程时，我们应该不惜一切代价地避免使用全局变量。

2.4.2　函数作用域

这是 JavaScript 主推的作用域机制。在函数中声明的任何变量都是局部且外部不可见的。同时，在函数返回后，其声明的任何局部变量都会被删除。所以，在函数中，变量 student 和 address 被绑定在 doWork() 中，无法被外界访问。如图2.5所示，变量名称解析与之前所述的原型名称解析链非常相似。它会首先检查最内层作用域，并逐渐向外。JavaScript 的作用域机制如下。

function doWork() {
   let student = new Student(...);
   let address = new Address(...);
   // do more work
};

图2.5　JavaScript 的名称解析顺序，在最近的作用域查找到变量，并逐层向外扩展。 它首先检查函数（局部）作用域，然后移动到（倘若存在的）父作用域，最终移动至 全局作用域。如果无法找到变量x ，该函数将返回 undefined

① 首先检查变量的函数作用域。

② 如果不是在局部作用域内，那么逐层向外检查各词法作用域，搜索该变量的引用，直到全局作用域。

③ 如果无法找到变量引用，那么JavaScript将返回undefined 。

考虑下面的代码示例：

var x = 'Some value';
function parentFunction() {
   function innerFunction() {
      console.log(x);
   }
   return innerFunction;
}
var inner = parentFunction();
inner();

当 inner 被调用时，JavaScript 运行时会按照图2.5中所示的顺序进行查找 x 。

2.4.3　伪块作用域

如果读者有任何其他编程语言的开发经验，很可能已经适应了函数作用域。但由于 JavaScript 类似 C 的语法，读者很可能也期望块作用域会以类似的方式工作。

遗憾的是，标准 ES5 JavaScript 并不支持块级作用域，这些块包裹在括号{} 中，隶属于各种控制结构，如 for 、while 、if 和 switch 语句。唯一的例外是传递到 catch 块的错误变量。语句 with 与块作用域类似，但它已不被建议使用，并且在严格模式下被禁止。在类似C的其他语言中，在 if 语句中声明的变量（即本例中的 myVar ），

if (someCondition) {
   var myVar = 10;
}

是无法从代码块外部访问的。因此，对于已经习惯该风格的 JavaScript 入门开发人员来说会比较困惑。因为拥有函数作用域的 JavaScript 语言能够在函数中的任何地方访问一个在代码块中声明的变量。尽管这可能是 JavaScript 开发人员的噩梦，但还是有办法来克服的。来看看下面的问题：

function doWork() {
   if (!myVar) {
      var myVar = 10;
   }
   console.log(myVar); //-> 10
}
doWork();

变量 myVar 是在 if 语句中声明的，但它是块外部可见的。奇怪的是，该代码运行后打印的结果是 10 。这很令人困惑，特别是对于那些用惯了块级作用域的开发者来说。JavaScript 有一个内部机制将所有声明的变量和函数提取至当前作用域的顶部，本例中是函数作用域。这会使得循环不再安全，注意清单2.4所示的例子。

清单 2.4　有歧义的循环计数器问题

var arr = [1, 2, 3, 4];
function processArr() {

   function multipleBy10(val) {
        i = 10;
        return val * i;
   }

   for(var i = 0; i < arr.length; i++) {
      arr[i] = multipleBy10(arr[i]);
   }

   return arr;
}
processArr(); //-> [10, 2, 3, 4]

该循环计数器 i 被移动到函数的顶部，并成为 multipleBy10 函数闭包的一部分。在 i 的声明中忘记使用关键字 var 导致在 multiplyBy10 的局部作用域创建了一个已经存在于作用域的变量，不慎将循环计数器修改为 10 。该循环计数器的声明被提取置顶，并被设置为 undefined ，之后在执行循环时被赋值为0 。在第8章中，你会在处理循环中的非阻塞操作中再次看到这种有歧义的代码问题。

良好的IDE和代码检查工具可以缓和这些问题，但当面对几百行代码时，即便是这些工具也爱莫能助。在下一章中，我们将会了解到一些更好的解决方案，它们更加优雅，比起标准的循环也更不易出错，能够充分地利用高阶函数来克服这些语言缺陷。正如本章所述的，JavaScript ES6 提供了 let 关键字通过将循环计数器与循环块绑定的方式来解决这个问题：

for(let i = 0; i < arr.length; i++) { <--- let关键字解决了置顶问题（hoisting problem），i被定义在正确的作用域中。循环外部为定义i
   // ...
}

i; // i === undefined

这是一个进步，也是我为什么更推荐使用let 而不是var 来声明作用域变量的原因。然而，标准的代码循环还有一些其他缺点，我们将在下一章对此进行讨论。现在，既然你已经了解了函数闭包的组成以及其工作机制，让我们来看看一些闭包的实际应用。

2.4.4　闭包的实际应用

闭包在很多大型的 JavaScript 实际场景中都有十分重要的应用。尽管它们并不全是函数式编程项目，但都对 JavaScript 的以下函数作用机制充分加以利用。

• 模拟私有变量。
• 异步服务端调用。
• 创建人工块作用域变量。

1．模拟私有变量

与JavaScript不同，很多其他语言提供了一个内置的机制，通过设置访问修饰符（如 private ）来定义对象的内部属性。JavaScript 并没有一个固有的关键字来限定在对象作用域中私有变量和函数的访问。这种封装特性有利于程序的不可变性，因为你无法修改不能访问的东西。

我们可以使用闭包来模仿这种行为。其中一个例子就是像之前的 zipCode 和 coordinate 函数一样返回一个对象。这些函数返回一个字面的对象，尽管其中包含了一些可访问任何外部函数局部变量的方法，但并不会公开这些变量，因此可以有效地使这些变量私有化。

闭包还可以用来管理的全局命名空间，以免在全局范围内共享数据。一些库和模块还会使用闭包来隐藏整个模块的私有方法和数据。这被称为模块模式 ，它采用了立即调用函数表达式（IIFE） ，在封装内部变量的同时，允许对外公开必要的功能集合，从而有效减少了全局引用。

注意

　

将所有的功能代码包裹在良好封装的模块之中是一个通用的最佳实践。你可以将在本书中学到的所有函数式编程核心原则用在模块之中。

以下是一个模块框架的简单示例[ 3] ：

var MyModule = (function MyModule(export) { <---给IIFE一个名字，这样有用的信息更方便栈追踪
    let _myPrivateVar = ...;  <---无法从外部访问到这个私有变量，但对内部的两个方法可见

   export.method1 = function () { <---需要暴露的方法，这里给予了伪命名空间
        // do work
    };

    export.method2 = function () { <---需要暴露的方法，这里给予了伪命名空间
        // do work
    };
}(MyModule || {})); <---一个单例对象，用来私有的封装所有的状态和方法。可以通过MyModule.method1()调用到method1()

对象 MyModule 是在全局作用域创建的，之后被传递给一个用function 关键字创建的函数表达式中，并会在脚本加载时被立即执行。由于JavaScript的函数作用域，变量_myPrivateVar 和其他私有变量都是包裹函数的局部变量。围绕这两个公开方法的闭包使得返回的对象能够安全地访问模块中的所有内部属性。能够在暴露一个包含大量被封装的状态和行为的对象的同时，尽可能地减少对全局的污染，这种能力确实引人注目。该模块模式被应用于本书涉及的每一个函数式库之中。

2．异步服务端调用

JavaScript中的一等高阶函数可以作为回调函数传递到其他函数中。回调函数和钩子一样，能够非侵入式地处理各种事件。假设需要对服务器发起一次请求，并期望在数据被接收到时得到通知。常用的方式就是提供一个回调函数来处理服务器响应：

getJSON('/students',
   (students) => {
       getJSON('/students/grades',
          grades => processGrades(grades),  <---处理两个返回结果
          error => console.log(error.message));  <---处理获取评分等级时发生的错误
   },
   (error) =>
     console.log(error.message)  <---处理获取学生时发生的错误
)

getJSON 是一个高阶函数，它接收两个回调作为参数——一个处理成功的函数和一个处理错误的功能。一种伴随异步事件处理代码的常见现象是，当需要进行多次远程请求的情况下，很容易落入多层嵌套的函数调用中，这些回调会形成糟糕的“回调厄运金字塔”。正如你可能经历过的，代码在嵌套过深时会变得难以理解。在第8章，你将学到一些最佳实践，通过使用更加流式和声明式的表达式，并将其连接在一起来到替代这种代码嵌套。

3．模拟块作用域变量

闭包为代码示例2.4中的循环计数器问题提供了一个替代解决方案。正如前面提到的，问题的根本是JavaScript缺乏块作用域的语义，因此需要人为地制造出块作用域。该怎么做呢？使用let 确实可以缓解许多传统的循环机制问题，然而使用一种基于forEach 的函数式方法则可以对闭包以及 JavaScript 的函数作用域加以利用。这样就无须考虑如何将循环计数器以及其他变量约束在作用域之中，而可以在循环体内包裹一个函数作用域来模拟块作用域。后面还会看到，这可以帮助在遍历集合时进行异步调用：

arr.forEach(function(elem, i) {
   ...
});

本章所涵盖的仅仅是JavaScript的基础知识，来帮助读者了解它的一些局限性，为后续深入了解函数式技术做好准备。如果想更加深入地了解语言，读者应参考一本深刻讲解对象、继承以及闭包等概念的书籍。

想要成为一个 JavaScript 忍者吗？

本章涉及对象、函数、作用域以及闭包等主题，这对成为一名 JavaScript 专家至关重要。但本章仅仅介绍了一些皮毛，因为这可以使读者可以更加专注于函数式编程。如果想要获得更多的信息，精进JavaScript技能水平，建议您阅读John Resig*、* Bear Bibeault 以及 Josip Maras所著的《JavaScript 忍者秘籍》（第2版）（2016，www.manning.com/books/secrets-of-the- javascript-ninja-second-edition，中文版由人民邮电出版社于2018年2月出版，ISBN978-7- 115-47326-4，定价69元）。

现在读者已经有了坚实的JavaScript基础，在下一章中，我们将看看如何使用如map 、reduce 以及filter 等操作以及递归的方法来进行数据处理。

2.5　总结

• JavaScript 是一种用途广泛的、具有强大面向对象和函数式编程特性的语言。
• 使用不可变的实现方式可以使函数式与面向对象编程很好地结合在一起。
• 一等高阶的函数使得 JavaScript 成了函数式编程的中坚力量。
• 闭包具有很多实际用途，如信息隐藏、模块化开发，并能够将参数化的行为跨数据类型地应用于粗粒度的函数之上。

[1] 该引用更适用于面向对象的实践者而不是语言范式本身。包括Gang of Four在内的许多该领域的专家，都更倾向于使用对象组合而不是基于里氏替换原则的类型继承。

[2] 尽管该对象的内部状态得到了保护，但其行为仍然可变，因为可以动态地删除或替换它的任何方法。

[3] 对于模块模式的不同种类的更进一步的说明，请参阅Ben Cherry在Adequately Good 中发表的文章：《JavaScript Module Pattern: In-Depth》，2010年3月12日，http://mng.bz/H9hk。

第二部分　函数式基础

第一部分回答了本书的两个最根本的问题：为什么要选择函数式以及为什么要选择JavaScript。既然明白了函数式编程给 JavaScript 开发带来的好处，我们会继续深入讲解。第二部分将探讨一些实用概念，应用函数式编程来解决现实问题。在这一部分中，读者会了解到“函数式”的意义。

第 3 章通过让读者了解通用函数式程序中如 map、 reduce 和 filter 这样的命令式抽象函数，来学习如何创建易于推断的代码。本章还涵盖了函数式风格中用于数据迭代的重要手段，即递归的使用。

第 4 章将着眼于第 3 章中的概念应用，学习如何采用 Pointfree 风格基于流式的函数构建来简化软件开发。读者将了解到，将复杂任务拆分为独立的、粒度较小的组件是构建函数式代码的核心。而这些组件最终会通过函数式中的组合原则拼接在一起，形成最终的模块化可重用的解决方案。

第 5章将介绍如何应用一些基本的设计模式来克服程序复杂性的增加以及错误处理等问题。一些抽象数据类型，如 Functor 和 Monad，可以提供一个在异常条件下可容错的弹性抽象层，使用它们可以使函数的组合更加稳定可靠。

第二部分中的技术会完全改变读者编写 JavaScript 代码的方式，同时也为在第三部分中使用函数式技术解决如异步数据以及事件这样的复杂 JavaScript 问题打下基础。

第3章　轻数据结构，重操作

本章内容

• 理解程序的控制流
• 更易理解的代码与数据
• 命令抽象函数map、reduce 以及filter
• Lodash.js 及函数链
• 递归的思考

计算过程是计算机中的一种抽象存在，在其演化的过程中，这些过程会去控制另一种被称为数据的抽象存在。

——Harold Abelson，Gerald Jay Sussman（《Structure and Interpretation

of Computer Programs, MIT Press, 1979年》

本书第一部分完成了两个重要目标：一方面，其中的章节教读者如何用函数式思考，同时介绍了一些函数式编程中需要用到的工具；另一方面，让读者了解了许多核心的 JavaScript 特性，尤其是高阶函数——它们都会在本章和本书的其余部分频繁用到。现在，读者应该已经了解到如何使函数变得更纯，是该学习如何连接它们的时候了。

本章将介绍一些使用的操作，如map 、reduce 以及filter ，它们能够连续地遍历并变换各种数据结构。这些操作十分重要，几乎所有的函数式程序都会以各种方式来使用它们。它们也用于去除代码中的循环——大多数循环都是可由这些函数处理的一些具体案例。

读者还将在本章学习JavaScript 函数库 Lodash.js。它不但能够处理应用程序的结构，还能够处理各种数据结构。此外，本章还将讨论在函数式编程中具有重要作用的递归，以及用递归思考的优势。基于这些概念，你将能够编写出简洁的、可扩展的、声明式的程序代码，并能够使代码中的主逻辑与控制流清晰地分离。

3.1　理解程序的控制流

程序为实现业务目标所要行进的路径被称为控制流。命令式程序需要通过暴露所有的必要步骤才能极其详细地描述其控制流。这些步骤通常涉及大量的循环和分支，以及随语句执行变化的各种变量。简单的命令式程序大致可以这样描述：

var loop = optC();
while(loop) {
   var condition = optA();
   if(condition) {
     optB1();
   }
   else {
     optB2();
   }
   loop = optC();
}
optD();

图3.1显示了上述程序的简单流程图。

图3.1　通过分支和循环控制操作（或语句）组成的命令式程序

然而，声明式程序，特别是函数式程序，则多使用以简单拓扑连接的独立黑盒操作组合而成的较小结构化控制流，从而提升程序的抽象层次。这些连接在一起的操作只是一些能够将状态传递至下一个操作的高阶函数，如图3.2所示。使用函数式开发风格操作数据结构，其实就是将数据与控制流视为一些高级组件的简单连接。

图3.2　连接黑盒操作的函数式控制流程。信息在一个操作与下一个（独立的纯函数）操作 之间独立地流动。高阶抽象使得分支和迭代明显减少或甚至被消除

使用这种方式可以形成类似这样的代码：

optA().optB().optC().optD();      <--- 这样用点连接表示有共同的对象上定义过这些方法

采用这种链式操作能够使程序简洁、流畅并富有表现力，能够从计算逻辑中很好地分离控制流，因此可以使得代码和数据更易推理。

3.2　链接方法

方法链 是一种能够在一个语句中调用多个方法的面向对象编程模式。当这些方法属于同一个对象时，方法链又称为方法级联 。尽管该模式大多出现在面向对象的应用程序中，但在一些特定条件下，如操作不可变对象时，也能很好地用于函数式编程中。既然在函数式代码中是禁止修改对象的，又如何能使用这种方法链模式呢？让我们来看一个字符串处理的例子：

'Functional Programming'.substring(0, 10).toLowerCase() + ' is fun';

在该例中，substring 和 toLowerCase 都是（通过 this ）在隶属的字符串对象上操作并返回一个新字符串的方法。JavaScript 中字符串的加号（+ ）运算符被重载为连接字符串操作的语法糖，它也会返回一个新的字符串。通过一系列变换后的结果与原先字符串毫无引用关系，而原先的字符串也不会有任何变化。这种行为是理所当然的，因为按照设计，字符串是不可变的。从面向对象的角度来看，这没有什么特别的。但从函数式编程的角度来看，这是一种理想行为，因为不需要使用 Lenses 来进行字符串变换了。

如果用更加函数式的风格重构上面的代码，它会像这样：

concat(toLowerCase(substring('Functional Programming', 1, 10))),' is fun');

这段代码符合函数式风格，所有参数都应在函数声明中明确定义，而且它没有副作用，也不会修改的原有对象。但可以说，这样的代码写起来并没有方法链流畅。而且它也更难阅读，因为需要一层层地剥离外部函数，才能知晓内部真正发生的事情。

只要遵守不可变的编程原则，函数式中也会应用这种隶属于单个对象实例的方法链。能用该模式来处理数组变换吗？其实 JavaScript 也将这种字符串的行为推广到数组上了，大多数人之所以还在用for 循环作为权宜之计，是因为他们并不了解这些特性。

3.3　函数链

面向对象程序将继承作为代码重用的主要机制。回忆之前章节中，Student 类继承了父类 Person 的所有状态和方法。读者也许在一些纯面向对象的语言中更多见到的是这种模式，特别是在数据结构的实现代码中。例如在 Java 中，有一大堆继承于基础接口 List 的各种实体List 类，如ArrayList 、LinkedList 、DoublyLinkedList 、CopyOnWrite ArrayList 等，它们都源自共同的父类，并各自添加了一些特定的功能。

函数式编程则采用了不同的方式。它不是通过创建一个全新的数据结构类型来满足特定的需求，而是使用如数组这样的普通类型，并施加在一套粗粒度的高阶操作之上，这些操作是底层数据形态所不可见的。这些操作会作如下设计。

• 接收函数作为参数，以便能够注入解决特定任务的特定行为。
• 代替充斥着临时变量与副作用的传统循环结构，从而减少所要维护以及可能出错的代码。

让我们仔细研究一下。本章中的示例都是基于一个 Person 对象的集合。为了方便起见，我们只声明四个对象，但相同的概念同样适用于较大的集合：

const p1 = new Person('Haskell', 'Curry', '111-11-1111');
p1.address = new Address('US');
p1.birthYear = 1900;

const p2 = new Person('Barkley', 'Rosser', '222-22-2222');
p2.address = new Address('Greece');
p2.birthYear = 1907;

const p3 = new Person('John', 'von Neumann', '333-33-3333');
p3.address = new Address('Hungary');
p3.birthYear = 1903;

const p4 = new Person('Alonzo', 'Church', '444-44-4444');
p4.address = new Address('US');
p4.birthYear = 1903;

3.3.1　了解lambda表达式

lambda表达式 （在JavaScript中也被称为箭头函数 ）源自函数式编程，比起传统的函数声明，它可以采用相对简洁的语法形式来声明一个匿名函数。尽管 lambda 函数也可以写成多行形式，但就像在第2章中见到的，单行是最普遍的形式。使用 lambda 表达式或普通函数声明语法一般只会影响到代码的可读性，其本质是一样的。下面是一个可用于提取个人姓名的示例函数：

const name = p => p.fullname;
console.log(name(p1)); //-> 'Haskell Curry'

(P) => p.fullname 这种简洁的语法糖表明它只接收一个参数p 并隐式地返回p.fullname 。图3.3显示了这种新语法的结构。

图3.3　箭头函数的结构。lambda函数的右侧可以是一个表达式或是一个封闭的多个语句块[ 1]

lambda表达式适用于函数式的函数定义，因为它总是需要返回一个值。对于单行表达式，其返回值就是函数体的值。另一个值得注意的是一等函数与lambda表达式之间的关系。函数名代表的不是一个具体的值，而是一种（惰性计算的）可获取其值的描述。换句话说，函数名指向的是代表着如何计算该数据的箭头函数。这就是在函数式编程中可以将函数作为数值使用的原因。我们将在本章进一步讨论它，并在第7章讨论惰性计算函数。

此外，函数式编程中鼓励使用的map 、reduce 以及 filter 等核心高阶函数都能够与 lambda 表达式良好地配合使用。很多函数式的 JavaScript 代码都需要处理数据列表，这也就是衍生 JavaScript 的函数式语言鼻祖起名为 LISP（列表处理）的原因。JavaScript 5.1 本身就提供特定版本的该类操作——称为函数式array extras 。但为了能够联合其他相似操作以提供完整的解决方案，本书会选择使用 Lodash.js 函数式库中提供的此类操作。它的工具包包含丰富的能够处理常见编程任务的基础函数（安装方法见附录），因此非常利于编写函数式程序。安装之后，就可以通过全局的 _ （下画线符号）对象来访问其功能。下面先来介绍 _.map 。

Lodash 中的下画线

Lodash 之所以使用下画线约定，是因为它是从著名且广泛使用的 Undesrscore.js 项目中衍生而来（http://underscorejs.org/）。为了能够直接替换 Underscore，Lodash 仍然保持与其一致的 API。但从本质上讲，为了能够以更为优雅的方式构建函数链，本书将完全重写lodash，这也伴随着一些性能的提升（我们将在第7章深入了解）。

3.3.2　用_.map做数据变换

假设需要对一个较大数据集合中的所有元素进行变换，例如，从一个学生对象的列表中提取每个人的全名。你曾经有多少次不得不写出这样的语句？

var result = [];
var persons = [p1, p2, p3, p4];
for(let i = 0; i < persons.length; i++) {
   var p = persons[i];
   if(p !== null && p !== undefined) {
        result.push(p.fullname);      <--- 命令式的方案会假设fullname是Student的方法
   }
}

高阶函数 map （也称为collect ）能够将一个迭代函数有序地应用于一个数组中的每个元素，并返回一个长度相等的新数组。以下是使用_.map 的函数式风格版本：

_.map(persons,
    s => (s !== null && s !== undefined) ? s.fullname : '' <--- 通过高阶函数去掉了所有var声明
);

该操作的标准定义如下：

map(f, [e0, e1, e2...]) -> [r0, r1, r2...];  其中, f(en) = rn

如果整个集合元素需要进行变换，map 函数是极其有用的——再也不必编写循环，并处理奇怪的作用域问题了。此外，由于其是不可变的，因此输出是一个全新的数组。map 需要以一个函数f 以及拥有*n*个元素的集合作为输入，由左到右对每个元素应用函数f 后，返回一个长度为*n*的新数组。该行为如图3.4所示。

图3.4　操作 map 对数组的每个元素应用迭代函数 f ，并返回一个等长的数组

在 _.map 的例子中，我们遍历了学生的对象数组并提取出他们的名字。可以用 lambda 表达式作为迭代函数（这是通常的做法）。原有的数组不会被改变，而新返回的数组包含以下元素：

['Haskell Curry', 'Barkley Rosser', 'John von Neumann', 'Alonzo Church']

理解抽象层次背后的事情永远是有好处的，下面来看 map 是如何实现的（见清单3.1）。

清单3.1　Map的实现

function map(arr, fn) {      <--- 接收一个函数和一个数组，应用函数到数组中的每一个元素，然后返回同样大小的新数组
  let idx    = 0,
       len    = arr.length,
       result = new Array(len);      <--- 结果：一个与输入数组同样长度的数组

   while (++idx < len) {
       result[index] = fn(array[idx], idx, arr);      <--- 应用函数fn到数组中的每一个元素，再把结果放入数组
   }
   return result;
}

如上所示，_.map 也是基于标准循环的。该函数已经处理了迭代的逻辑，因此无须为一些如循环变量或边界检查这样的琐事而操心，只需关注在迭代函数中功能逻辑的合理性即可。这个例子展示了函数式库如何辅助开发者写出纯函数式的代码。

map 是一个只会从左到右遍历的操作，对于从右到左的遍历，必须先反转数组。JavaScript 中的 Array.reverse() 操作是不能在这里使用的，因为它会改变原数组。可以将Lodash中功能等价的 reverse 操作与 map 连接起来写成一行：

_(persons).reverse().map(
    p => (p !== null && p !== undefined) ? p.fullname : ''
);

请注意该例子中语法的细小区别。Lodash 提供了一种不错的非侵入式的方式来与代码继承。开发者所需要做的就是用符号_(...) 将要操作的对象包起来，这样就拥有了其强大功能的完全控制，可以实现任何想要的变换。

容器的映射

将数据结构（即例子中的数组）映射为转换后的值，这个理念具有更加深远的意义。正如可以用任意函数映射一个数组，也可以用函数映射一个对象（见第5章）。

现在可以在数据上应用一个变换函数了。如果能够基于新的结构得出某个结果就更好了。这就是 reduce 函数要做的事了。

3.3.3　用_.reduce 收集结果

转换数据之后，如何从中收集具有意义的结果呢？假设要从一个 Person 对象集合中计算出人数最多的国家，就可以使用 reduce 函数来实现。

高阶函数reduce 将一个数组中的元素精简为单一的值。该值是由每个元素与一个累积值通过一个函数计算得出的，如图3.5所示。

图3.5　将数组 reduce 为单一值。每次迭代都会计算出基于先前结果的累积值， 直至到达数组的末尾。reduce 的最终结果始终是单一值

图3.5可以更正式地表示为以下描述：

reduce(f,[e0, e1, e2, e3],accum) -> f(f(f(f(acc, e0), e1, e2, e3)))) -> R

现在来看一个 reduce 函数的简单实现，如清单3.2所示。

清单3.2　reduce 的实现

function reduce(arr, fn,[accumulator]) {
   let idx = -1,
       len = arr.length;

   if (!accumulator && len > 0) {      <--- 如果不提供累加值，就会用第一个元素作为累加值
      accumulator = arr[++idx];
   }

  while (++idx < len) {
      accumulator = fn(accumulator,      <--- 应用fn到每一个元素，将结果放到累加值中
      arr[idx], idx, arr);
   }
   return accumulator;      <--- 返回累加值
}

reduce 需要接收以下参数。

• fn ——迭代函数会应用于数组的每个元素，其参数包含累积值、当前值、当前索引以及数组本身。
• 累加器——累积初始值，之后会用于存储每次迭代函数的计算结果，并不断被传入子函数中。

下面写一个简单的程序来收集一个 Person 对象数组的一些统计数据。假设要找住在某个特定国家的人数，如清单3.3所示。

清单3.3　国家人数计算

_(persons).reduce(function (stat, person) {
    const country = person.address.country; <--- 抽取国家信息
   stat[country] = _.isUndefined(stat[country]) ? 1 : <--- 记录人数， 初始为 1，每当找到同样国家的同学则加 1
         stat[country] + 1;
   return stat; <---  返回累加值
}, {}); <--- 以空对象作为初始累加器

这段代码能够将输入的数组转换为表征各国人数的单一对象：

{
    'US'     : 2,
    'Greece' : 1,
    'Hungary': 1
}

为进一步简化，可以使用普适的 map-reduce 组合。通过链接这些函数，并提供具有特定行为的函数参数，就可以提高 map 和 reduce 函数的威力。抽象地讲，该程序流将具有如下结构：

_(persons).map(func1).reduce(func2);

其中，func1 和func2 用于实现所需的特定行为。清单3.4展示了将业务函数与控制流分离的方法。

清单3.4　结合map 与reduce 进行统计计算

const getCountry = person => person.address.country;

const gatherStats = function (stat, criteria) {
   stat[criteria] = _.isUndefined(stat[criteria]) ? 1 :

       stat[criteria] + 1;
   return stat;
};

_(persons).map(getCountry).reduce(gatherStats, {});

清单 3.4 中使用 map 将对象数组进行预处理，提取出所有国家信息。之后，再使用 reduce 来收集最终的结果。这段代码与清单 3.3具有完全相同的输出，但更加清晰并更具可扩展性。与其直接去访问对象属性，不如考虑（使用Ramda）提供的lens来访问 address.city 属性：

const cityPath = ['address','city'];
const cityLens = R.lens(R.path(cityPath), R.assocPath(cityPath));

这样就能够很容易地基于人们所处的城市计算出结果：

_(persons).map(R.view(cityLens)).reduce(gatherStats, {});

此外，还可以使用 _.groupBy 函数以一种更加简洁的方式来获得同样的结果：

_.groupBy(persons, R.view(cityLens));

与 map 不同，由于 reduce 依赖于累积的结果，如果不使用满足交换率的操作，从左到右与从右到左的计算可能产生不同的结果。为了说明这一点，考虑一个数组求和的简单程序：

_([0,1,3,4,5]).reduce(_.add);  //-> 13

使用反向的操作 _.reduceRight 函数也能够获得同样的结果。这是因为加法是一种满足交换律的运算，反之则有可能产生完全不同的结果，比如采用除法运算。如果使用之前的符号描述，_.reduceRight 可以作如下表示：

reduceRight(f, [e0, e1, e2],accum) -> f(e0, f(e1, f(e2, f(e3,accum)))) -> R

举例来说，以下两个使用 _.divide 的程序将计算出完全不同的结果：

([1,3,4,5]).reduce(_.divide) !== ([1,3,4,5]).reduceRight(_.divide);

此外，reduce 是一个会应用到所有元素的操作，这意味着没有办法将其“短路”来避免其应用于整个数组。假设需要对一组输入值进行校验，也许你会想用 reduce 将其转换为一个布尔值来表示所有参数是否合法。但是，使用 reduce 会比较低效，因为它会访问列表中的每一个值。其实，一旦找到了一个无效的输入，就不必继续校验剩下的值了。让我们看看如何使用 _.some 以及其他如 _.isUndefined 和_.isNull 这样的有趣函数来进行更高效的验证。当要应用于列表中的每个元素时，_.some 函数能够在找到第一个真值（true ）后立即返回：

const isNotValid = val => _.isUndefined(val) || _.isNull(val); <--- undefined 与 null 时为不合法

const notAllValid = args => (_(args).some(isNotValid)); <--- 函数 some 会在遍历到第一个 true 时返回， 这在寻找数组中是否存在合法值时非常有用

validate (['string', 0, null, undefined]) //-> false
validate (['string', 0, {}])              //-> true

还可以使用与非全真的逻辑非（也就是全真）函数 _.every ，无论对单个元素返回 true 与否，都会检查所有元素。

const isValid = val => !_.isUndefined(val) && !_.isNull(val);
const allValid = args => _(args).every(isValid);

allValid(['string', 0, null]); //-> false
allValid(['string', 0, {}]);   //-> true

正如前面所看到的，无论是 map 还是 reduce 都会遍历整个数组。通常并不想处理数据结构中的所有元素，而是期望跳过任何为 null 或 undefined 的值。要是在计算之前有一个能够去除或过滤掉列表中某些元素的方法就更好了。下面介绍_.filter 函数。

3.3.4　用_.filter 删除不需要的元素

在处理较大的数据集合时，往往需要删除部分不能参与计算的元素。例如，需要计算只生活在欧洲国家的人或是出生在某一年的人。与其在代码中到处用 if-else 语句，不如用 _.filter 来实现。

filter （也称为select ）是一个能够遍历数组中的元素并返回一个新子集数组的高阶函数，其中的元素由谓词函数 p 计算得出的 true 值结果来确定。正式的符号描述如图3.6所示。

filter(p, [d0, d1, d2, d3...dn]) -> [d0,d1,...dn] （输入的子集）

图3.6　filter 操作以一个数组为输入，并施加一个选择条件 p ，从而产生一个可能较 原数组更小的子集。条件p 也称为函数谓词

一种 filter 的实现如清单3.5所示。

清单3.5　filter 的实现

function filter(arr, predicate) {
   let idx = -1,
       len = arr.length,
       result = []; <--- 结果数组为原数组的子集

   while (++idx < len) {
     let value = arr[idx];
    if (predicate(value, idx, this)) { <--- 调用谓词函数，如果结果为真，则保留，否则略过
       result.push(value);
     }
   }
   return result;
}

除了需要提供数组外，filter 需要接收一个可用于测试数组中每个元素的 predicate 谓词函数。如果谓词为 true ，则将该元素保留在结果中，否则略过。这就是为什么通常会用 filter 从数组中删除无效数据：

＿(persons).filter(isValid).map(fullname);

但它的应用不止如此。假设需要从 Person 对象集合中提取生于1903年的人，那么用_.filter 要比使用条件语句更简单明了：

const bornIn1903 = person => person.birthYear === 1903;

＿(persons).filter(bornIn1903).map(fullname).join(' and ');

//-> 'Alonzo Church and Haskell Curry'

数组推导式

map 和 filter 都是能够根据当前数组生成新数组的高阶函数。很多如 Haskell 和 Clojure 等函数式语言中都能看到它们的身影。组合 map 和 filter 的另一种方法是使用数组推导式 ——也被称为列表推导式 。这是一种使用关键字 for…of 和 if 的简明语法并能够将 map 和 filter 的功能封装在一起的函数式特性：

[for (x of iterable) if (condition) x]

在撰写本文时，ECMAScript 7 中存在一个增加数组推导式的提议。它能用简洁的表达式来组装新数组（这也就是为什么整个表达式被包裹在 [] 中）。例如，之前的代码可以如下重构：

[for (p of people) if (p.birthYear ===  1903) p.fullname]
  .join(' and ');

这些技术的应用都基于这些具有扩展性和强大功能的函数，它们不仅有助开发者写出干净的代码，还能够提高开发者对数据的理解。使用声明式的编程风格，开发者可以专注于应用程序的输出，而不是其实现，从而更深地理解应用程序。

3.4　代码推理

回想一下，在JavaScript中，共享着一个全局命名空间的成千上万行代码被一次性加载到单个页面中。尽管最近业务逻辑的模块划分领域得到了越来越多的重视，但仍有数以千计生成中的项目没有这么做。

那么“代码推理”到底是什么意思呢？之前的章节用“松散”这个词来表征分析一个程序任何一个部分，并建立相应心智模型的难易程度。该模型分为两部分：动态部分包括所有变量的状态和函数的输出，而静态部分包含可读性以及设计的表达水平。两个部分都很重要。读者将在本书中了解到，不可变性和纯函数会使得该模型的构建更加容易。

之前的内容强调将高阶操作链接起来构成程序的价值。命令式的程序流与函数式的程序流有着本质的不同。函数式的控制流能够在不需要研究任何内部细节的条件下提供该程序意图的清晰结构，这样就能更深刻地了解代码，并获知数据在不同阶段是如何流入和流出的。

3.4.1　声明式惰性计算函数链

第1章中提到，函数式程序是由一些简单函数组成的，尽管每个函数只完成一小部分功能，但组合在一起就能够解决很多复杂的任务。本节将介绍一种能够连接一组函数来构建整个程序的方法。

函数式编程的声明式模型将程序视为对一些独立的纯函数的求值，从而在必要的抽象层次之上构建出流畅且表达清晰的代码。这样就可以构成一个能够清晰表达应用程序意图的本体或词汇表。使用如 map 、reduce 和 filter 这样的基石来搭建纯函数，可使代码易于推理并一目了然。

这个层次的抽象的强大之处在于，它会使开发者开始认识到各种操作应该对所采用的底层数据结构不可见。从理论上说，无论是使用数组、链表、二叉树还是其他数据结构，它都不应该改变程序原本的语义。正是出于这个原因，函数式编程选择更关注于操作而不是数据结构。

例如，假设需要对一组姓名进行读取、规范化、去重，最终进行排序。首先写一个命令式的版本，然后再重构成函数式的风格。

这个格式不一致的姓名字符串数组可以表示为：

var names = ['alonzo church', 'Haskell curry', 'stephen_kleene',
             'John Von Neumann', 'stephen_kleene'];

其命令式的程序如清单3.6所示。

清单3.6　对数组进行一系列操作（命令式风格）

var result = [];
for (let i = 0; i < names.length; i++) { <--- 遍历数组中的所有名字
   var n = names[i];
  if (n !== undefined && n !== null) { <--- 检查所有词是否都合法
      var ns = n.replace(/_/, ' ').split(' '); <--- 数组包含格式不一致的数据。这是规范化（修复）元素的步骤
      for(let j = 0; j < ns.length; j++) {
         var p = ns[j];
        p = p.charAt(0).toUpperCase() + p.slice(1);
         ns[j] = p;
      }
      if (result.indexOf(ns.join(' ')) < 0) { <--- 检查是否已存在于结果中，以去除重复的元素
         result.push(ns.join(' '));
     }
   }
}
result.sort(); <--- 数组排序

这段代码能够产生所需的输出：

['Alonzo Church', 'Haskell Curry', 'Jon Von Neumann', 'Stephen Kleene']

命令式代码的缺点是限定于高效地解决某个特定的问题。例如，清单 3.6 只能用于解决上述的问题。因此，比起函数式代码，其抽象水平要低得多。抽象层次越低，代码重用的概率就会越低，出现错误的复杂性和可能性就会越大。

此外，函数式的实现不过是将各种黑盒组件连接在一起，将重任赋予如清单3.7列出的这些成熟且经过测试的API。请注意，级联排列的函数调用可以使该代码更易阅读。

清单3.7　数组的（函数式）序列操作

_.chain(names) <--- 初始化函数链（该话题会马上涉及）
    .filter(isValid) <--- 去除非法值
    .map(s => s.replace(/_/, ' ')) <--- 规范化值
   .uniq() <--- 去掉重复元素
   .map(_.startCase) <--- 大写首字母
    .sort()
    .value();

//-> ['Alonzo Church', 'Haskell Curry', 'Jon Von Neumann', 'Stephen Kleene']

_.filter 和 _.map 函数承担了在 names 数组中迭代出有效索引的责任。开发者唯一的工作就是在剩下的步骤中给出指定的行为。先使用 _.uniq 函数去掉重复的条目，再用 _.startCase 函数大写所有的单词，最后对结果进行排序。

读者是不是也更期望阅读和编写像清单3.7这样的程序呢？不仅是因为代码量的减少，还因为其结构简单明了。

下面继续探索 Lodash。重拾清单3.4，它从一个 Person 对象数组中计算所有国家的计数。为了本例的目的，增加了一个 gatherStats 函数：

const gatherStats = function (stat, country) {
   if(!isValid(stat[country])) {
      stat[country] = {'name': country, 'count': 0};
   }
   stat[country].count++;
   return stat;
};

现在返回一个具有以下结构的对象：

{
   'US'      : {'name': 'US', count: 2},
   'Greece'  : {'name': 'Greece', count: 1},
   'Hungary' : {'name': 'Hungary', count: 1}
}

采用这种结构保证了每个国家拥有唯一的条目。为了再让它变得有趣一些，下面再给本章一开始给出的 Person 数组注入一些数据：

const p5 = new Person('David', 'Hilbert', '555-55-5555');
p5.address = new Address('Germany');
p5.birthYear = 1903;

const p6 = new Person('Alan', 'Turing', '666-66-6666');
p6.address = new Address('England');
p6.birthYear = 1912;

const p7 = new Person('Stephen', 'Kleene', '777-77-7777');
p7.address = new Address('US');
p7.birthYear = 1909;

接下来的任务是建立一个程序，返回该数据集中人数最多的国家。通过使用 _.chain() 和一些其他组件，再次将这些函数连接起来，如清单3.8所示。

清单3.8　Lodash惰性计算函数链

_.chain(persons) <--- 创建惰性计算函数链来处理给定的数组
    .filter(isValid)
   .map(_.property('address.country')) <--- 使用 _.property 抽取 person 对象的address.country 属性。这是 Ramda 的R.view() 的 Lodash 对应版本，虽然Lodash 的版本没有那么功能丰富
    .reduce(gatherStats, {})
    .values()
    .sortBy('count')
    .reverse()
    .first()
    .value() <--- 执行函数链中的所有函数
    .name; //-> 'US'

_.chain 函数可以添加一个输入对象的状态，从而能够将这些输入转换为所需输出的操作链接在一起。与简单地将数组包裹在_(…) 对象中不同，其强大之处在于可以链接序列中的任何函数。尽管这是一个复杂的程序，但仍然可以避免创建任何变量，并且有效地消除所有循环。

使用 _.chain 的另一个好处是可以创建具有惰性计算能力的复杂程序，在调用 value() 前，并不会真正地执行任何操作。这可能会对程序产生巨大的影响，因为在不需要其结果的情况下，可以跳过运行所有函数（见第7章中关于惰性计算的讨论）。该程序的控制流程如图3.7所示。

图3.7　Lodash 函数链程序的控制流程。通过一系列操作对person对象数组进行处理。 数据沿着函数链传递，并最终转化为单一值

现在读者应该开始明白为什么函数式的程序是如此优越的了。而相应的命令式版本留给读者去思考。清单3.8能够写得如此流畅与函数式编程中的纯性以及无副作用的基本原则息息相关。链中的每个函数都以一种不可变的方式来处理由上一个函数构建的新数组。Lodash 利用函数链这种模式，通过调用 _.chain() 提供了一种基础功能，以满足各种需求。这有助于过渡到对point-free 编程风格的理解。point-free是函数式编程的特色，将在下一章中介绍。

能够惰性地定义程序的管道不止有可读性这一个好处。由于以惰性计算方式编写的程序会在运行前定义好，因此可以使用数据结构重用或者方法融合等技术对其进行优化。这些优化不会减少执行函数本身所需的时间，但有助于消除不必要的调用。第7章研究函数式程序性能时，会更详细地进行讨论。

在清单3.8中，数据从一个节点流向下一个节点。声明式地使用高阶函数，使得节点中数据变换显而易见，从而揭示了更多对数据的认识。

3.4.2　类SQL的数据：函数即数据

本章已经介绍了各种各样的函数，比如map 、reduce 、filter 、groupBy 、sortBy 、uniq 等。将这些函数组成一个列表，可用来梳理数据相关的信息。如果在更高层面细细思考，就会发现这些函数与SQL相似，这不是偶然的。

开发者惯于使用SQL及其功能来了解和梳理数据的含义。例如，可以用表3.1所示的内容来表示person对象的集合。

表3.1　　表格化的person数据表示

事实证明，在构建程序时，使用查询语言来思考与函数式编程中操作数组类似——使用通用关键字表或代数方法来增强对数据及其结构的深层次思考。下面的SQL查询语句

SELECT p.firstname, p.birthYear FROM Person p
WHERE p.birthYear > 1903 and p.country IS NOT 'US'
GROUP BY p.firstname, p.birthYear

使开发者能够清楚地看到运行此代码后数据是什么样子的。在实现此程序的 JavaScript 版本之前，先设置一些函数别名来辅助说明这一点。Lodash支持一种称为mixins 的功能，可以用来为核心库扩展新的函数，并使得它们可以以相同的方式连接：

_.mixin({'select':  _.pluck,
         'from':    _.chain,
         'where':   _.filter,
         'groupBy': _.sortByOrder});

应用此 mixin 对象后，就可以编写出如清单3.9所示的程序。

清单3.9　编写类似 SQL 的 JavaScript 代码

_.from(persons)
  .where(p => p.birthYear > 1900 && p.address.country !== 'US')
  .groupBy(['firstname', 'birthYear'])
  .select('firstname', 'birthYear')
  .value();

//-> ['Alan', 'Barkley', 'John']

清单3.9创建了一个SQL关键字到对应别名函数的映射，从而可以更深刻地理解一个查询语言的函数式特性。

JavaScript中的mixin

mixin 是定义与特定类型（也就是上例中 SQL 命令）相关的函数的抽象子集对象。该对象在代码中不会被直接使用，而是作为对另一个对象行为的扩展（它有点类似于其他编程语言中的特质）。目标对象则能够使用 mixin 中的各种功能。

在面向对象的世界中，除了继承或者在不支持的语言中（比如 JavaScript 就是其中之一）模拟地多重继承，mixin是另一种代码重用的方式。本书中过多地介绍mixin，但如果能够正确使用，它会很强大。更多关于mixin的信息，参见https://javascriptweblog.wordpress.com/ 2011/05/31/a-fresh-look-at-javascript-mixins/。

现在读者应该相信，函数式编程的抽象能力比命令式代码更加强大。还有比使用查询语言的语义来处理和解析数据更好的方法吗？像SQL一样，上面的 JavaScript 代码以函数的形式对数据进行建模，也就是函数即数据 。因为它是声明式的，描述了数据输出是什么 ，而不是数据是如何得到的 。到目前为止，并不需要任何常见的循环语句——本书的其余部分也不打算使用它们。相反，应该用高阶抽象代替循环。

另一种用于替换循环的常见技术是递归，尤其当处理一些“自相似”的问题时，可以用其来抽象迭代。对于这些类型的问题，序列函数链会显得效率低下或不适用。而递归实现了自己的处理数据的方式，从而大大缩短了标准循环的执行时间。

3.5　学会递归地思考

有时，要解决的问题是困难且复杂的。这种情况下，开发者应该立刻去寻找方法来分解它。如果问题可以分解成较小的问题，就可以逐个解决，再将这些结论组合起来构建出整个问题的解决方案。在Haskell、Scheme和Erlang这样的纯函数编程语言中，数组遍历是不能没有递归的，因为这些语言根本没有循环结构。

而在JavaScript中，递归具有许多应用场景，例如解析XML、HTML文档或图形等。本节将解释什么是递归，然后通过一个练习教读者如何去递归地思考，最后将概述可以使用递归解析的几种数据结构。

3.5.1　什么是递归？

递归是一种旨在通过将问题分解成较小的自相似问题来解决问题本身的技术，将这些小的自相似问题结合在一起，就可以得到最终的解决方案。递归函数包含以下两个主要部分。

• 基例（也称为终止条件）。
• 递归条件。

基例是能够令递归函数计算出具体结果的一组输入，而不必再重复下去。递归条件则处理函数调用自身的一组输入（必须小于原始值）。如果输入不变小，那么递归就会无限期地运行，直至程序崩溃。随着函数的递归，输入会无条件地变小，最终到达触发基例的条件，以一个值作为递归过程的终止。

第2章使用递归来深度冻结整个嵌套的对象结构。如果遇到的对象是基本类型或已经被冻结，就会触发基例；否则，就会继续遍历对象结构，因为发现了更多未被冻结的对象。递归很适合处理这种问题，因为在任何一个层次上，要解决的任务是完全一样的。但是，递归思考可能会是一个挑战，下面开始吧。

3.5.2　学会递归地思考

递归不是一个容易掌握的概念。与函数式编程一样，最难的部分是忘记常规的方法。本书的重点不是让读者成为一个递归大师，因为它不是一种常用的技术手段。但重要的是，本书期望通过它来锻炼读者的大脑，并帮助读者更好地学习如何分析可递归的问题。

递归地思考需要考虑递归自身以及自身的一个修改版本。递归对象是自定义的。例如，想象将树枝组合成一棵树。一个树枝有叶子以及其他的树枝，而它们又有更多的叶子和更多的树枝。这个过程将无限地持续下去，只有在达到外部限制时才会停止，本例中就是树的大小。

下面基于这一思想来解决一个简单的问题：对数组中的所有数求和。先实现命令式的版本，再实现函数式的版本。命令式的大脑可以自然而然地形成一个解决方案，遍历数组并不断地累积一个值：

var acc = 0;
for(let i = 0; i < nums.length; i++) {
    acc += nums[i];
}

通常开发者会使用一个累加器，因为要计算一个总和时，这绝对是必要的。但是需要使用循环吗？在这一点上，开发者很清楚可以使用函数式的武器（例如_.reduce ）：

_(nums).reduce((acc, current) => acc + current, 0);

将循环抽成框架，可以将应用程序代码抽象出来。但是可以做得更好，从代码中彻底移除迭代。使用函数 _.reduce 无须考虑循环，甚至是数组的大小。可以通过将第一个元素添加到其余部分来计算结果，从而实现递归思维。这种思想过程可以想象成如下的序列求和操作，这被称为横向思维：

sum[1,2,3,4,5,6,7,8,9] = 1 + sum[2,3,4,5,6,7,8,9]
                       = 1 + 2 + sum[3,4,5,6,7,8,9]
                       = 1 + 2 + 3 + sum[4,5,6,7,8,9]

递归和迭代是一枚硬币的两面。在不可变的条件下，递归提供了一种更具表现力、强大且优秀的迭代替代方法。事实上，纯函数式语言甚至没有标准的循环结构，如 do 、for 和 while ，因为所有循环都是递归完成的。递归使代码更易理解，因为它是以多次在较小的输入上重复相同的操作为基础的。清单3.10中的递归解决方案使用 Lodash 的 _.first 和 _.rest 函数分别访问数组的第一个元素和剩余元素。

清单3.10　递归求和

function sum(arr) {
   if(_.isEmpty(arr)) { <--- 基例（终止条件）
      return 0;
   }
  return _.first(arr) + sum(_.rest(arr)); <--- 递归条件：使用更小一些的输入集调用自身。这里通过_.first和_.rest 缩减输入集
}
sum([]); //-> 0
sum([1,2,3,4,5,6,7,8,9]); //->45

空数组会满足基例，返回 0。而对于非空数组，就会继续将第一个元素与数组的其余部分递归地求和。从底层来看，递归调用会在栈中不断堆叠。当算法满足终止条件时，运行时就会展开调用栈并执行加操作，因此所有返回语句都将被执行。递归就是通过语言运行时这种机制代替了循环。以下是算法实现的步骤视图：

1 + sum[2,3,4,5,6,7,8,9]
1 + 2 + sum[3,4,5,6,7,8,9]
1 + 2 + 3 + sum[4,5,6,7,8,9]
1 + 2 + 3 + 4 + sum[5,6,7,8,9]
1 + 2 + 3 + 4 + 5 + sum[6,7,8,9]
1 + 2 + 3 + 4 + 5 + 6 + sum[7,8,9]
1 + 2 + 3 + 4 + 5 + 6 + 7 + sum[8,9]
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + sum[9]
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + sum[]
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0     -> halts, stack unwinds
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
1 + 2 + 3 + 4 + 5 + 6 + 7 + 17
1 + 2 + 3 + 4 + 5 + 6 + 24
1 + 2 + 3 + 4 + 5 + 30
1 + 2 + 3 + 4 + 35
1 + 2 + 3 + 39
1 + 2 + 42
1 + 44
45

看到这里，自然要考虑一下递归和迭代的性能问题。毕竟，编译器在处理循环的优化问题上是非常强大的。JavaScript 的 ES6 带来了一种称之为尾调用优化 的优化功能，可以使递归和迭代的性能表现更加接近。考虑一个稍微有所不同的sum 实现：

function sum(arr, acc = 0) {
   if(_.isEmpty(arr)) {
      return 0;
   }
   return sum(_.rest(arr), acc + _.first(arr)); <--- 发生在尾部的递归调用
}

这个版本的实现将递归调用作为函数体中最后的步骤，也就是尾部位置 。在第7章讨论函数式优化问题时，我们会探索这样做的好处。

3.5.3　递归定义的数据结构

读者可能想知道person 对象示例数据中的那些名字。20世纪 20 年代，函数式编程（lambda 演算、范畴论等）背后的数学社区非常活跃。大部分发表的研究成果都是融合一些由Alonzo Church 这样的知名大学教授提出的思想和定理。事实上，许多数学家，如Barkley Rosser、Alan Turing和Stephen Kleene等，都是Church 的博士生。后来他们也有了自己的博士生。图3.8为这种师徒关系（的一部分）的示意图。

图3.8　函数式编程发展历程中具有杰出贡献和影响力的数学家。树形结构中从父节点到 子节点的连线代表了“是其学生”这种关系

这种结构在软件中是很寻常的，它可用于建模XML文档、文件系统、分类法、种别、菜单部件、逐级导航、社交图谱等，所以学习如何处理它们至关重要。图3.8显示了一组节点，其连线表示了导师-学生这一关系。到目前为止，本书已经利用函数式技术解析过一些扁平化的数据结构，如数组。但这些操作对树形数据是无效的。因为 JavaScript 没有内置的树型对象，所以需要基于节点创建一种简单的数据结构。节点是一种包含了当前值、父节点引用以及子节点数组的对象。在图3.8中，Rosser 的父节点是 Church ，其子节点有 Mendelson 和 Sacks 。如果一个节点没有父节点，比如 Church ，则被称为根节点。以下是节点 类型的定义，代码如清单3.11所示。

清单3.11　节点对象

class Node {
     constructor(val) {
       this._val = val;
       this._parent = null;
       this._children = [];
     }

     isRoot() {
        return isValid(this._parent); <--- 之前创建的函数
     }

     get children() {
       return this._children;
     }
     hasChildren() {
        return this._children.length > 0;
     }

     get value() {
       return this._val;
    }

     set value(val) {
       this._val = val;
    }

     append(child) {
        child._parent = this; <--- 设置父节点
           this._children.push(child); <--- 将孩子节点加入孩子列表中
       return this; <--- 返回该节点（便于方法级联）
     }
      toString() {
        return `Node (val: ${this._val}, children:
           ${this._children.length})`;
     }
}

可以这样创建一个新节点：

const church = new Node(new Person('Alonzo', 'Church', '111-11-1111'));// <--- 重复树中的所有节点

树是包含了一个根节点的递归定义的数据结构：

class Tree {
   constructor(root) {
      this._root = root;
   }

   static map(node, fn, tree = null) { <--- 使用静态方法以免与Array.prototype.map 混淆。静态方法也能像单例函数一样高效
      node.value = fn(node.value); <--- 调用遍历器函数，并更新树中的节点值
      if(tree === null) {
           tree = new Tree(node); <--- 与 Array.prototype.map 类似。结果是一个新的结构
      }


      if(node.hasChildren()) { <--- 如果节点没有孩子，则返回（基例）
        _.map(node.children, function (child) { <--- 将函数应用到每一个孩子节点
            Tree.map(child, fn, tree); <--- 递归地调用每一个孩子节点
        });
      }
      return tree;
   }
   get root() {
      return this._root;
   }
}

节点的主要逻辑在于 append 方法。要给一个节点追加一个子节点，需要将该节点设置为子节点的 parent 引用，并把子节点添加至该节点的子节点列表中。通过从根部不断地将节点链接到其他子节点来填充一棵树，由 church 开始：

church.append(rosser).append(turing).append(kleene);
kleene.append(nelson).append(constable);
rosser.append(mendelson).append(sacks);
turing.append(gandy);

每个节点都包裹着一个 person 对象。递归算法执行整个树的先序遍历，从根开始并且下降到所有子节点。由于其自相似性，从根节点遍历树和从任何节点遍历子树是完全一样的，这就是递归定义。为此，可以使用与 Array.prototype.map 语义类似的高阶函数 Tree.map ——它接收一个对每个节点求值的函数。可以看出，无论用什么数据结构来建模（这里是树形数据结构），该函数的语义应该保持不变。从本质上讲，任何数据类型都可以使用map并保持其结构不变。本书第5章会更正式地介绍这种保持数据结构的映射函数。

树的先序遍历按照以下步骤执行，从根节点开始。

1）显示根元素的数据部分。

2）通过递归地调用先序函数来遍历左子树。

3）以相同的方式遍历右子树。

图3.9显示了算法采用的路径。

图3.9　递归的先序遍历，从根节点开始，一直向左下降，然后再向右移动

函数 Tree.map 有两个必需的输入：根节点（即树的开始）以及转换每个节点数值的迭代函数：

Tree.map(church, p => p.fullname);

它以先序方式遍历树，并将给定的函数应用于每个节点，输出以下结果：

'Alonzo Church', 'Barkley Rosser', 'Elliot Mendelson', 'Gerald Sacks', 'Alan
Turing', 'Robin Gandy', 'Stephen Kleene', 'Nels Nelson', 'Robert Constable'

在操作不可变、无副作用的数据类型时，封装数据以控制其访问的思想是函数式编程的关键。本书第5章将进一步介绍这一思想。解析数据结构是软件和函数式编程最基本的方面之一。本章更深入地探讨了利用可扩展函数库（即Lodash）中的函数式特性来进行函数式风格的 JavaScript 开发。这种风格有利于流式建模，将包含业务逻辑的高阶操作连接在一起，从而达到最终的业务目的。

不可否认的是，编写流式风格的代码也有利于可重用性和模块化，但目前的讨论还比较浅显。本书第4章更深入地介绍流式编程，将重点放在构建真正的函数管道上。

3.6　总结

• 使用map 、reduce 和filter 等高阶函数来编写高可扩展的代码。
• 使用Lodash进行数据处理，通过控制链创建控制流与数据变换明确分离的程序。
• 使用声明式的函数式编程能够构建出更易理解的程序。
• 将高阶抽象映射到SQL语句，从而深刻地认识数据。
• 递归能够解决自相似问题，并解析递归定义的数据结构。

[1] 只有一个参数时其实括号是可以省略的。——译者注

第4章　模块化且可重用的代码

本章内容

• 函数链与函数管道的比较
• Ramda.js 函数库
• 柯里化、部分应用（partial application）和函数绑定
• 通过函数式组合构建模块化程序
• 利用函数组合子增强程序的控制流

一个复杂的工作系统总是从一个简单的系统发展而来的。

——John Gall，《The System Bible》（General Systemantics Press，2012年）

模块化是大型软件项目最重要的特性之一，它代表了将程序分成较小独立部分的程度。模块化程序的独特之处在于，其含义来自于其组成部分的性质。这些部分（或称为子程序）都是可重复使用的组件，并可以合并为一个系统整体或单独在其他系统中使用。这使代码更加可读和可维护，同时使开发更加高效。举一个简单的例子，UNIX脚本程序的编写：

tr 'A-Z' 'a-z' <words.in | uniq | sort

即便没有UNIX编程的经验，也可以清楚地看到，这行代码包括对字符的一系列变换：将大写转换为小写，删除重复字符，最终进行排序。管道操作符“| ”用于连接这些命令。令人惊奇的是，通过明确地描述命令输入和输出的约定，一些小程序就可以合在一起来解决更为复杂的任务。假设用传统的命令式JavaScript来编写这个程序，可能需要几个循环、字符串比较，或许还需要一些条件语句以及一些全局变量来记录状态。这应该不是很模块化的，对吧？在编程中，开发者倾向于先将问题分解成较小的部分，再重建这些部分以形成整体的解决方案。

第3章通过一个被包裹对象上的紧耦合级联方法链解决了类似的问题。本章将进一步扩展该思路，通过函数组合创建松耦合的管道，以便能够使用独立组件更灵活地构建整个程序。这些组件可以像函数一样小，也可以像整个模块一样大。分开来看，它们并没有太大的价值，但组合在一起就会颇具意义。

创建模块化的代码也不是一件很容易的事情。本章将借助Ramda.js函数框架来了解一些重要的函数式技术，如部分求值和组合，通过将代码抽象到合理的层次，以便构建出一种声明式管道的point-free风格的解决方案。

4.1　方法链与函数管道的比较

第3章提到了连接一系列函数的方法链，从而揭示了一种与众不同的函数式编程风格。还有一种称为管道 的方法也可以用来连接函数。

函数的输入和输出对于了解函数本身是十分重要的。Haskell中使用一种符号来描述函数，这常见于各种地方，例如一些函数式社区（见图4.1）。

图4.1　Haskell中定义函数的符号。该符号先给出了函数的名称， 随后用一个操作符来设置函数的输入和输出类型

请记住，在函数式编程中，函数是输入和输出类型之间的数学映射，如图4.2所示。举例来说，一个简单的函数，如isEmpty ，它接收一个字符串并返回一个布尔值，使用该符号表示如下：

isEmpty :: String -> Boolean

图4.2　函数**isEmpty**是所有String类型输入值的集合到所有Boolean类型输出值的集合之间的引用透明映射

该函数是所有String 类型输入值到所有Boolean 值之间的引用透明映射。该函数JavaScript的lambda描述形式如下：

// isEmpty :: String -> Boolean
const isEmpty = s => !s || !s.trim();

了解函数作为类型映射的性质是理解如何将函数链接和管道化的关键。

• 方法链接（紧耦合，有限的表现力）。
• 函数的管道化（松耦合，灵活）。

4.1.1　方法链接

回想一下，在第3章中，map 和filter 函数都以一个数组作为输入并返回一个新的数组。这些函数都可以通过Lodash封装的隐式对象紧密地连接在一起，从而在后台实现对新数据结构的创建。这是第3章中的一个例子：

_.chain(names)
    .filter(isValid) <--- 每一个“点”后只能调用 Lodash 提供的方法
    .map(s => s.replace(/_/, ' '))
    .uniq()
    .map(_.startCase)
    .sort()
    .value();

比较命令式代码，这的确是一个能够极大提高代码可读性的语法改进。然而，它与方法所属的对象紧紧地耦合在一起，限制链中可以使用的方法数量，也就限制了代码的表现力。这样就只能够使用由Lodash提供的操作，而无法轻松地将不同函数库的（或自定义的）函数连接在一起。

注意

尽管使用mixin的方法可以扩展一个对象的功能，但这就需要自己去管理mixin对象本身。本书并未过多涉及mixin的讨论，但读者可以在《重新审视的JavaScript Mixins》（Angus Croll，2011年5月30日，http://mng.bz/15Zj）一书中了解更多。

从高阶函数角度来看，可以一组对数组操作的简单方法序列表示为图4.3所示的形式。打破函数链的约束就能够自由地排列所有独立的函数操作，而可以使用函数管道来实现这一目的。

图4.3　数组的方法链需要通过调用所属对象中的方法来实现。而从 内部来看，每个方法都会返回一个含有调用结果的新数组

4.1.2　函数的管道化

函数式编程能够消除方法链中存在的限制，使得任何函数的组合都更加灵活。管道是松散结合的有向函数序列，一个函数的输出会作为下一个函数的输入。图4.4抽象地说明了以不同类型对象作为输入的函数的连接方式。

图4.4　函数管道始于具有类型**A**参数的函数**f**，产生一个类型**B**的对象， 随后按序传入函数**g**，并以输出的类型**C**对象作为最终结果。函数 **f** 和**g**既可以来自于任何函数库，也可以是自定义的函数

本章将介绍如何将函数调用组织成图4.4所示的简洁高阶函数管道。如果觉得该图表很熟悉，那是因为该模式就是许多企业应用程序中都能够看到的面向对象设计模式中的管道与过滤器模式，它是从函数式编程衍变而来的（其中的过滤器就是各个函数）。

比较图4.3和图4.4就会发现一个关键的区别：方法链接通过对象的方法紧密连接；而管道以函数作为组件，将函数的输入和输出松散地连接在一起。但是，为了实现管道，被连接的函数必须在元数（arity）和类型上相互兼容。

4.2　管道函数的兼容条件

面向对象的编程在一些特定情况下（其中之一是认证与授权）偶尔会使用管道。而函数式编程将管道视为构建程序的唯一方法。通常来说，对于不同的任务，问题的定义与解决方案间总是存在很大的差异。因此，特定的计算必须在特定的阶段进行。这些阶段由不同的函数表征，而所选函数的输入和输出需要满足以下两个兼容条件。

• 类型——函数的返回类型必须与接收函数的参数类型相匹配。
• 元数——接收函数必须声明至少一个参数才能处理上一个函数的返回值。

4.2.1　函数的类型兼容条件

在设计函数管道时，函数的返回类型与函数的接收参数之间具有一定程度的兼容性是极其重要的。由于JavaScirpt是弱类型语言，因此从类型角度来看，无须像使用一些静态类型语言一样太过关注类型。因此，如果一个对象在应用中表现得像某个特定类型，那么它就是该类型。这也被称为鸭子类型：“如果走起来像鸭子，并且像鸭子一样叫，那这就是一只鸭子。”

注意

静态类型语言的优势是使用类型系统在无须运行代码的情况下发现潜在的问题。类型系统是函数式编程中的一个重要课题，但本书不会涉及。

JavaScript的动态调度机制会尝试在对象中查找属性与方法，而不关注类型信息。虽然这非常灵活，但开发者仍然需要了解一个函数所期望的参数类型。使用清晰的定义（例如在代码中使用Haskell符号标记）可以使程序更易理解。

正式地讲，仅当f 的输出类型等同于函数g 的输入时，两个函数f 和g 是类型兼容的。举例来说，一个处理学生社会安全号码的简单程序：

trim      :: String   -> String <--- 截掉首末空白符
normalize :: String   -> String <--- 去除横线

此时，normalize 的输入与trim 的输出服从兼容性的对应关系，因此可以像清单4.1所示的代码一样，在一个简单的管道序列中调用它们。

清4.1　使用 trim 和normalize 手动构建函数管道

// trim :: String -> String
const trim = (str) => str.replace(/^\s*|\s*$/g, '');

// normalize :: String -> String
const normalize = (str) => str.replace(/\-/g, '');

normalize(trim(' 444-44-4444 ')); //-> '444444444' <--- 手动构建系列管道调用两个函数（之后会涉及如何自动化这一过程）。使用带有首末空白符的输入测试

类型固然重要，但在JavaScript中，更关键的是函数元数的兼容性。

4.2.2　函数与元数：元组的应用

元数定义为函数所接收的参数数量，也被称为函数的长度（length）。尽管在其他编程范式中，元数是最基本的，但在函数式编程中，引用透明的必然结果就是，声明的函数参数数量往往与其复杂性成正比。例如，操作一个字符串的函数很可能比具有3个或4个参数的函数简单得多：

// isValid :: String -> Boolean
function isValid(str) { <--- 使用简单
     ...
}

// makeAsyncHttp:: String, String, Array -> Boolean
function makeAsyncHttp (method, url, data) { <--- 难以使用，因为必须先计算出所有参数
    ...
}

只具有单一参数的纯函数是最简单的，因为其实现目的非常单纯，也就意味着职责单一。因此，应该尽可能地使用具有少量参数的函数，这样的函数更加灵活和通用。然而，总是使用一元函数并非那么容易。例如，在真实世界中，isValid 函数可能会额外返回一个描述错误信息的值：

isValid :: String -> (Boolean, String) <--- 返回含有验证状态或错误信息的结构体

isValid(' 444-444-44444'); //-> (false, 'Input is too long!')

但如何返回两个不同的值呢？函数式语言通过一个称为元组 的结构来做到这一点。元组是有限的、有序的元素列表，通常由两个或三个值成组出现，记为(a, b,c) 。由此，可以使用一个元组作为isValid 函数的返回值——它将状态与可能的错误消息捆绑，作为单个实体返回，并随后传递到另一个函数中（如果需要的话）。下面详细探讨一下元组。

元组是不可变的结构，它将不同类型的元素打包在一起，以便将它们传递到其他函数中。将数据打包返回的方式还包括字面对象或数组等：

return {
   status : false,                or

 return [false, 'Input is too long!'];
   message: 'Input is too long!'
};

但当涉及函数间的数据传输时，元组能够具有更多的优点。

• 不可变的——一旦创建，就无法改变一个元组的内部内容。
• 避免创建临时类型——元组可以将可能毫不相关的数据相关联。而定义和实例化一些仅用于数据分组的新类型使得模型复杂并令人费解。
• 避免创建异构数组——包含不同类型元素的数组使用起来颇为困难，因为会导致代码中充满大量的防御性类型检查。传统上，数组意在存储相同类型的对象。

此外，元组的行为与第2章中显示的数值对象极为相似。一个具体的用例是 Status ，它是一个包含状态标志和一条消息的简单数据类型：(false, 'Some error occurred!') 。与其他函数式语言（如Scala）不同，JavaScript并不原生地支持Tuple 数据类型。例如，给定一个Scala中的元组定义：

var t = (30, 60, 90)

可以像这样访问各个元素：

var sumAnglesTriangle = t._1 + t._2 + t._3 = 180

但是，JavaScript已经提供了实现元组所需的所有工具，如清单4.2所示。

清单4.2　Tuple 数据类型

const Tuple = function( /* types */ ) {

   const typeInfo = Array.prototype.slice.call(arguments, 0); <--- 读取参数作为元组的元素类型

   const _T = function( /* values */ ) { <--- 声明内部类型_T，以保障类型与值匹配

      const values = Array.prototype.slice.call(arguments, 0); <--- 提取参数作为元组内的值

      if(values.some((val) => <--- 检查非空值。函数式数据类型不允许空值
         val === null || val === undefined)) {
         throw new ReferenceError('Tuples may not have
            any null values');
      }

      if(values.length !== typeInfo.length) { <--- 按照定义类型的个数检查元组的元数
         throw new TypeError('Tuple arity does not
            match its prototype');
      }

      values.map(function(val, index) { <--- 使用 checkType 检查每一个值都能匹配其类型定义。其中的元素都可以通过_n 获取， n 为元素的索引（注意是从 1 开始）
             this['_' + (index + 1)] = checkType(typeInfo[index])(val);
           }, this);
      Object.freeze(this); <--- 让元组实例不可变
   };

   _T.prototype.values = function() { <--- 提取元组中的元素，也可以使用 ES6 的解构赋值把元素赋值到变量上
         return Object.keys(this).map(function(k) {
              return this[k];
         }, this);
   };
   return _T;
};

清单4.2中定义的元组对象是不可变且长度固定的数据结构，是可用于在函数间通讯的存储了n 个不同类型值的异构集合。举例来说，可以用元组来快速构建如Status 这样的值对象：

const Status = Tuple(Boolean, String);

下面利用元组来完成学生的SSN验证，代码如清单4.3所示。

清单4.3　使用了元组的isValid 函数

// trim :: String -> String
const trim = (str) => str.replace(/^\s*|\s*$/g, '');

// normalize :: String -> String
const normalize = (str) => str.replace(/\-/g, '');

// isValid :: String -> Status
const isValid = function (str) {
    if(str.length === 0){
       return new Status(false, <--- 声明包含状态（ Boolean）和消息（ String）的类型Status
            'Invald input. Expected non-empty value!');
    }
    else {
       return new Status(true, 'Success!');
    }
}

isValid(normalize(strim('444-44-4444'))); //-> (true, 'Success!')

在软件开发过程中，二元组出现得非常频繁，将其设定为一等的对象非常具有实际意义。在JavaScript ES6解构赋值特性的支持下，可以简明地将元组值映射到变量中。清单4.4所示的代码使用元组创建了一个名为StringPair 的对象。

清单4.4　StringPair 类型

const StringPair = Tuple(String, String);
const name = new StringPair('Barkley', 'Rosser');

[first, last] = name.values();
first; //-> 'Barkley'
last; //-> 'Rosser'

const fullname = new StringPair('J', 'Barkley', 'Rosser'); <--- 抛出元素不匹配的错误

元组是减少函数元数的方式之一，但还可以使用更好的方式去应对那些不适于元组的情况。通过引入函数柯里化不仅可以降低元数，还可以增强代码的模块化和可重用性。

4.3　柯里化的函数求值

将函数的返回值作为参数传递给一元函数是十分容易的，但如果目标函数需要更多参数呢？为了理解JavaScript的柯里化，首先必须了解柯里化的求值和常规（非柯里化的）求值之间的区别。JavaScript是允许在缺少参数的情况下对常规或非柯里化函数进行调用的。换句话说，如果定义一个函数f(a, b, c) ，并只在调用时传递a ，JavaScript运行时的调用机制会将b 和c 设为undefined ，如图4.5所示。这并不是一件好事，也是JavaScript语言不能原生支持柯里化的最有可能的原因。可以想象，如果在函数声明时不定义任何参数，而仅依赖于函数中的arguments 对象，则会使问题变得更糟。

图4.5　在缺少参数的情况下调用非柯里化函数会导致缺失参数的实参变成 **undefined**

再看柯里化函数，它要求所有参数都被明确地定义，因此当使用部分参数调用时，它会返回一个新的函数，在真正运行之前等待外部提供其余的参数。图4.6能够直观地表现这一点。

图4.6 柯里化函数**f**的求值。只有提供了所有参数，该函数才会输出具体的结果， 否则它会返回另一个等待参数传递的函数

柯里化是一种在所有参数被提供之前，挂起或“延迟”函数执行，将多参函数转换为一元函数序列的技术。具有三个参数的柯里化函数的定义如下：

curry(f) :: (a,b,c) -> f(a) -> f(b)-> f(c)

以上符号描述表明，curry是一种从函数到函数的映射，将输入(a, b, c) 分解为多个分离的单参数调用。在纯函数式编程语言中（如Haskell），柯里化是原生特性，是任何函数定义中的组成部分。由于JavaScript本身不支持自动柯里化函数，因此需要编写一些代码来启用它。在了解自动柯里化之前，让我们先从二元参数的手动柯里化例子开始，代码如清单4.5所示。

清单4.5　二元参数的手动柯里化

function curry2(fn) {
     return function(firstArg) { <--- 第一次调用 curry2，获得第一个参数
          return function(secondArg) { <--- 第二次调用获得第二个参数
              return fn(firstArg, secondArg); <--- 将两个参数应用到函数 fn 上
          };
     };
}