开发者社区> 行者武松> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

了解JavaScript函数式编程(二)

简介:
+关注继续查看


上一篇文章里我们提到了纯函数的概念,所谓的纯函数就是,对于相同的输入,永远会得到相同的输出,而且没有任何可观察的副作用,也不依赖外部环境的状态(我偷懒复制过来的)。

但是实际的编程中,特别是前端的编程范畴里,“不依赖外部环境”这个条件是根本不可能的,我们总是不可避免地接触到 DOM、AJAX 这些状态随时都在变化的东西。所以我们需要用更强大的技术来干这些脏活。

一、容器、Functor

如果你熟悉 jQuery 的话,应该还记得,$(...) 返回的对象并不是一个原生的 DOM 对象,而是对于原生对象的一种封装:


  1. var foo = $('#foo'); 
  2.  
  3. foo == document.getElementById('foo'); 
  4.  
  5. //=> false 
  6.  
  7. foo[0] == document.getElementById('foo'); 
  8.  
  9. //=> true 

这在某种意义上就是一个“容器”(但它并不函数式)。

接下类我们会看到,容器为函数式编程里普通的变量、对象、函数提供了一层极其强大的外衣,赋予了它们一些很惊艳的特性,就好像 Tony Stark 的钢铁外衣,Dva 的机甲,明日香的2号机一样。

下面我们就来写一个最简单的容器吧:


  1. var Container = function(x) { 
  2.  
  3. this.__value = x; 
  4.  
  5.  
  6. Container.of = x => new Container(x); 
  7.  
  8. //试试看 
  9.  
  10. Container.of(1); 
  11.  
  12. //=> Container(1) 
  13.  
  14. Container.of('abcd'); 
  15.  
  16. //=> Container('abcd'

我们调用 Container.of 把东西装进容器里之后,由于这一层外壳的阻挡,普通的函数就对他们不再起作用了,所以我们需要加一个接口来让外部的函数也能作用到容器里面的值:


  1. Container.prototype.map = function(f){ 
  2.  
  3. return Container.of(f(this.__value)) 
  4.  

我们可以这样使用它:


  1. Container.of(3) 
  2.  
  3. .map(x => x + 1) //=> Container(4) 
  4.  
  5. .map(x => 'Result is ' + x); //=> Container('Result is 4'

没错!我们仅花了 7 行代码就实现了很炫的链式调用,这也是我们的第一个 Functor。

Functor(函子)是实现了 map 并遵守一些特定规则的容器类型。

也就是说,如果我们要将普通函数应用到一个被容器包裹的值,那么我们首先需要定义一个叫 Functor 的数据类型,在这个数据类型中需要定义如何使用 map 来应用这个普通函数。

把东西装进一个容器,只留出一个接口 map 给容器外的函数,这么做有什么好处呢?

本质上,Functor 是一个对于函数调用的抽象,我们赋予容器自己去调用函数的能力。当 map 一个函数时,我们让容器自己来运行这个函数,这样容器就可以自由地选择何时何地如何操作这个函数,以致于拥有惰性求值、错误处理、异步调用等等非常牛掰的特性。

举个例子,我们现在为 map 函数添加一个检查空值的特性,这个新的容器我们称之为 Maybe(原型来自于Haskell):


  1. var Maybe = function(x) { 
  2.  
  3. this.__value = x; 
  4.  
  5.  
  6. Maybe.of = function(x) { 
  7.  
  8. return new Maybe(x); 
  9.  
  10.  
  11. Maybe.prototype.map = function(f) { 
  12.  
  13. return this.isNothing() ? Maybe.of(null) : Maybe.of(f(this.__value)); 
  14.  
  15.  
  16. Maybe.prototype.isNothing = function() { 
  17.  
  18. return (this.__value === null || this.__value === undefined); 
  19.  
  20.  
  21. //试试看 
  22.  
  23. import _ from 'lodash'
  24.  
  25. var add = _.curry(_.add); 
  26.  
  27. Maybe.of({name"Stark"}) 
  28.  
  29. .map(_.prop("age")) 
  30.  
  31. .map(add(10)); 
  32.  
  33. //=> Maybe(null
  34.  
  35. Maybe.of({name"Stark", age: 21}) 
  36.  
  37. .map(_.prop("age")) 
  38.  
  39. .map(add(10)); 
  40.  
  41. //=> Maybe(31) 

看了这些代码,觉得链式调用总是要输入一堆 .map(...) 很烦对吧?这个问题很好解决,还记得我们上一篇文章里介绍的柯里化吗?

有了柯里化这个强大的工具,我们可以这样写:


  1. import _ from 'lodash'
  2.  
  3. var compose = _.flowRight; 
  4.  
  5. var add = _.curry(_.add); 
  6.  
  7. // 创造一个柯里化的 map 
  8.  
  9. var map = _.curry((f, functor) => functor.map(f)); 
  10.  
  11. var doEverything = map(compose(add(10), _.property("age"))); 
  12.  
  13. var functor = Maybe.of({name"Stark", age: 21}); 
  14.  
  15. doEverything(functor); 
  16.  
  17. //=> Maybe(31) 

二、错误处理、Either

现在我们的容器能做的事情太少了,它甚至连做简单的错误处理都做不到,现在我们只能类似这样处理错误:


  1. try{ 
  2.  
  3. doSomething(); 
  4.  
  5. }catch(e){ 
  6.  
  7. // 错误处理 
  8.  

try/catch/throw 并不是“纯”的,因为它从外部接管了我们的函数,并且在这个函数出错时抛弃了它的返回值。这不是我们期望的函数式的行为。

如果你对 Promise 熟悉的话应该还记得,Promise 是可以调用 catch 来集中处理错误的:


  1. doSomething() 
  2.  
  3. .then(async1) 
  4.  
  5. .then(async2) 
  6.  
  7. .catch(e => console.log(e)); 

对于函数式编程我们也可以做同样的操作,如果运行正确,那么就返回正确的结果;如果错误,就返回一个用于描述错误的结果。这个概念在 Haskell 中称之为 Either 类,Left 和 Right 是它的两个子类。我们用 JS 来实现一下:


  1. // 这里是一样的=。= 
  2.  
  3. var Left = function(x) { 
  4.  
  5. this.__value = x; 
  6.  
  7.  
  8. var Right = function(x) { 
  9.  
  10. this.__value = x; 
  11.  
  12.  
  13. // 这里也是一样的=。= 
  14.  
  15. Left.of = function(x) { 
  16.  
  17. return new Left(x); 
  18.  
  19.  
  20. Right.of = function(x) { 
  21.  
  22. return new Right(x); 
  23.  
  24.  
  25. // 这里不同!!! 
  26.  
  27. Left.prototype.map = function(f) { 
  28.  
  29. return this; 
  30.  
  31.  
  32. Right.prototype.map = function(f) { 
  33.  
  34. return Right.of(f(this.__value)); 
  35.  

下面来看看 Left 和 Right 的区别吧:


  1. Right.of("Hello").map(str => str + " World!"); 
  2.  
  3. // Right("Hello World!"
  4.  
  5. Left.of("Hello").map(str => str + " World!"); 
  6.  
  7. // Left("Hello"

Left 和 Right 唯一的区别就在于 map 方法的实现,Right.map 的行为和我们之前提到的 map 函数一样。但是 Left.map 就很不同了:它不会对容器做任何事情,只是很简单地把这个容器拿进来又扔出去。这个特性意味着,Left 可以用来传递一个错误消息。


  1. var getAge = user => user.age ? Right.of(user.age) : Left.of("ERROR!"); 
  2.  
  3. //试试 
  4.  
  5. getAge({name'stark', age: '21'}).map(age => 'Age is ' + age); 
  6.  
  7. //=> Right('Age is 21'
  8.  
  9. getAge({name'stark'}).map(age => 'Age is ' + age); 
  10.  
  11. //=> Left('ERROR!'

是的,Left 可以让调用链中任意一环的错误立刻返回到调用链的尾部,这给我们错误处理带来了很大的方便,再也不用一层又一层的try/catch。

Left 和 Right 是 Either 类的两个子类,事实上 Either 并不只是用来做错误处理的,它表示了逻辑或,范畴学里的coproduct。但这些超出了我们的讨论范围。

三、IO

下面我们的程序要走出象牙塔,去接触外面“肮脏”的世界了,在这个世界里,很多事情都是有副作用的或者依赖于外部环境的,比如下面这样:


  1. function readLocalStorage(){ 
  2.  
  3.   return window.localStorage; 
  4.  

这个函数显然不是纯函数,因为它强依赖外部的 window.localStorage 这个对象,它的返回值会随着环境的变化而变化。为了让它“纯”起来,我们可以把它包裹在一个函数内部,延迟执行它:


  1. function readLocalStorage(){ 
  2.  
  3.   return function(){ 
  4.  
  5.     return window.localStorage; 
  6.  
  7.   } 

这样 readLocalStorage 就变成了一个真正的纯函数! OvO为机智的程序员鼓掌!

额……好吧……好像确实没什么卵用……我们只是(像大多数拖延症晚期患者那样)把讨厌做的事情暂时搁置了而已。为了能彻底解决这些讨厌的事情,我们需要一个叫 IO 的新的 Functor:


  1. import _ from 'lodash'
  2.  
  3. var compose = _.flowRight; 
  4.  
  5. var IO = function(f) { 
  6.  
  7. this.__value = f; 
  8.  
  9.  
  10. IO.of = x => new IO(_ => x); 
  11.  
  12. IO.prototype.map = function(f) { 
  13.  
  14. return new IO(compose(f, this.__value)) 
  15.  
  16. }; 

IO 跟前面那几个 functor 不同的地方在于,它的 __value 是一个函数。它把不纯的操作(比如 IO、网络请求、DOM)包裹到一个函数内,从而延迟这个操作的执行。所以我们认为,IO 包含的是被包裹的操作的返回值。


  1. var io_document = new IO(_ => window.document); 
  2.  
  3. io_document.map(function(doc){ return doc.title }); 
  4.  
  5. //=> IO(document.title) 

注意我们这里虽然感觉上返回了一个实际的值 IO(document.title),但事实上只是一个对象:{ __value: [Function] },它并没有执行,而是简单地把我们想要的操作存了起来,只有当我们在真的需要这个值得时候,IO 才会真的开始求值,这个特性我们称之为 惰性求值。(培提尔其乌斯:“这是怠惰啊!”)

是的,我们依然需要某种方法让 IO 开始求值,并且把它返回给我们。它可能因为 map 的调用链积累了很多很多不纯的操作,一旦开始求值,就可能会把本来很干净的程序给“弄脏”。但是去直接执行这些“脏”操作不同,我们把这些不纯的操作带来的复杂性和不可维护性推到了 IO 的调用者身上(嗯就是这么不负责任)。

下面我们来做稍微复杂点的事情,编写一个函数,从当前 url 中解析出对应的参数。


  1. import _ from 'lodash'
  2.  
  3. // 先来几个基础函数: 
  4.  
  5. // 字符串 
  6.  
  7. var split = _.curry((char, str) => str.split(char)); 
  8.  
  9. // 数组 
  10.  
  11. var first = arr => arr[0]; 
  12.  
  13. var last = arr => arr[arr.length - 1]; 
  14.  
  15. var filter = _.curry((f, arr) => arr.filter(f)); 
  16.  
  17. //注意这里的 x 既可以是数组,也可以是 functor 
  18.  
  19. var map = _.curry((f, x) => x.map(f)); 
  20.  
  21. // 判断 
  22.  
  23. var eq = _.curry((x, y) => x == y); 
  24.  
  25. // 结合 
  26.  
  27. var compose = _.flowRight; 
  28.  
  29. var toPairs = compose(map(split('=')), split('&')); 
  30.  
  31. // toPairs('a=1&b=2'
  32.  
  33. //=> [['a''1'], ['b''2']] 
  34.  
  35. var params = compose(toPairs, last, split('?')); 
  36.  
  37. // params('http://xxx.com?a=1&b=2'
  38.  
  39. //=> [['a''1'], ['b''2']] 
  40.  
  41. // 这里会有些难懂=。= 慢慢看 
  42.  
  43. // 1.首先我们先对 url 调用 params 函数,得到类似[['a''1'], ['b''2']] 
  44.  
  45. // 这样的数组; 
  46.  
  47. // 2.然后调用 filter(compose(eq(key), first)),这是一个过滤器,过滤的 
  48.  
  49. // 条件是 compose(eq(key), first) 为真,它的意思就是只留下首项为 key 
  50.  
  51. // 的数组; 
  52.  
  53. // 3.最后调用 Maybe.of,把它包装起来。 
  54.  
  55. // 4.这一系列的调用是针对 IO 的,所以我们用 map 把这些调用封装起来。 
  56.  
  57. var getParam = key => map(compose(Maybe.of, filter(compose(eq(key), first)), params)); 
  58.  
  59. // 创建充满了洪荒之力的 IO!!! 
  60.  
  61. var url = new IO(_ => window.location.href); 
  62.  
  63. // 最终的调用函数!!! 
  64.  
  65. var findParam = getParam(url); 
  66.  
  67. // 上面的代码都是很干净的纯函数,下面我们来对它求值,求值的过程是非纯的。 
  68.  
  69. // 假设现在的 url 是 http://xxx.com?a=1&b=2 
  70.  
  71. // 调用 __value() 来运行它! 
  72.  
  73. findParam("a").__value(); 
  74.  
  75. //=> Maybe(['a''1']) 

四、总结

如果你还能坚持看到这里的话,不管看没看懂,已经是勇士了。在这篇文章里,我们先后提到了 Maybe、Either、IO 这三种强大的 functor,在链式调用、惰性求值、错误捕获、输入输出中都发挥着巨大的作用。事实上 functor 远不止这三种,但由于篇幅的问题就不再继续介绍了(哼才不告诉你其实是因为我还没看懂其它 functor 的原理)

但依然有问题困扰着我们:

  1. 如何处理嵌套的 functor 呢?(比如 Maybe(IO(42)))
  2. 如何处理一个由非纯的或者异步的操作序列呢?
作者:王伟嘉
来源:51CTO

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
什么是纯函数,JavaScript函数式编程的基础
云栖号资讯:【点击查看更多行业资讯】在这里您可以找到不同行业的第一手的上云资讯,还在等什么,快来! 导读:什么是 OAM?2019 年 10 月 17 日,阿里巴巴合伙人、阿里云智能基础产品事业部总经理蒋江伟(花名:小邪)在 QCon 上海 2019 重磅宣布,阿里云与微软联合推出开放应用模型 Open Application Model (OAM)开源项目。
380 0
Python全栈 Web(JavaScript DOM树、DOM对象、BOM对象)
外部对象: BOM和DOM BOM: Browser Object Module 浏览器对象模型 将浏览器比喻成一个对象-window (网页初始化自动创建) 可以通过window对象操作浏览器 DOM: Document Object .
2087 0
+关注
行者武松
杀人者,打虎武松也。
17111
文章
2569
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载