函数式编程（四）

函子（Functor）

函子的作用，在函数式编程中如何把反作用控制在可控的范围内、异常解决、异步操作等。

什么是 Functor

• 容器：包含值和值的变形关系(这个变形关系就是函数)
• 函子：是一个特殊的容器，通过一个普通的对象来实现，该对象具备 map 方法，map 方法可以运行一个函数对值进行解决(变形关系)
  看概念总是云里雾里的，但还是得多读几遍，我们来自己实现一个函子。

// Functor 函子class Container {   constructor (value) {     this._value = value // 函子中必需要有一个值，_开头商定为内部私有变量，不希望外部用到   }   map (fn) {     return new Container(fn(this._value)) // 传入的函数解决完此值后，需要再返回一个函子出去   } }// try let r = new Container(5) //return的是函子，能继续链式调用   .map(x => x + 1)   .map(x => x * x) console.log(r) // => {_value: 36} 注意map，

上面就是一个最简单的函子， 我们要解决值value，并不是函子来解决，是我们向map里传函数由他来解决。但是每次使用前还要new Container，不方便（更多的起因是由于函数式编程，我们可不想看见new这样的操作符，哈哈哈哈），于是

class Container {  static of (value) { // new是避免不了了，就封装一个of方法，在这里偷偷new    return new Container(value)   }  constructor (value) {    this._value = value  }  map (fn) {    return Container.of(fn(this._value)) //of是静态方法，这里即可以直接用类名调用  }}// try let r = Container.of(3)   .map(x => x + 2)   .map(x => x * x) console.log(r) // => {_value: 25} 

所以函子就是一个拥有map方法的对象，函子中要维护一个值（也就是你传进来的），这个值永远也不对外公布，就像这个值被包裹在一个盒子里面，想操作值就往map中传函数就行了。

总结

• 函数式编程的运算不直接操作值，而是由函子完成
• 函子就是一个实现了 map 契约的对象
• 我们可以把函子想象成一个盒子，这个盒子里封装了一个值想要解决盒子中的值，我们需要给盒子的 map 方法传递一个解决值的函数（纯函数），由这
  个函数来对值进行解决
• 最终 map 方法返回一个包含新值的盒子（函子）

基本就是这样，当然它是不会这么简单的，我们用函子的目的就是用它来解决反作用

// 值假如不小心传入了空值(反作用)Container.of(null).map(x => x.toUpperCase())// TypeError: Cannot read property 'toUpperCase' of null

MayBe 函子

我们在编程的过程中可能会遇到很多错误，需要对这些错误做相应的解决
MayBe 函子的作用就是可以对外部的空值情况做解决（控制反作用在允许的范围）

class MayBe {  static of (value) {    return new MayBe(value)  }  constructor (value) {    this._value = value  } isNothing () { // 这里新添加一个判断能否为空的函数    return this._value === null || this._value === undefined  }  map (fn) { // 在执行fn前判断一下，为空时就返回一个null的函子    return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this._value))  }}

相比以前加了个判断而已，我们trytry

 let r = MayBe.of(null)           .map(x => x.toUpperCase()) console.log(r) // => {_value: null}  也没没有报错// 他还是不够完善，请看MayBe.of('hello beijing').map(x => x.toUpperCase()).map(x => null) // 假设这里出现了问题，产生了null传递了下去.map(x => x.split(' '))// =>  { _value: null }

尽管兜住了，但是Meybe很难追踪到出现问题的地方，没关系我们有Either 函子

Either 函子

• Either 两者中的任何一个，相似于 if…else…的解决
• 异常会让函数变的不纯，Either 函子可以用来做异常解决

// 这里我们需要两个函子left rightclass Left {  static of (value) {    return new Left(value)  }  constructor (value) {    this._value = value  }  map (fn) {    return this // 这里比较特殊，是直接返回这个对象，这里为何这样下面解释  }}// 这个right跟以前的Container没有区别class Right {    static of (value) {        return new Right(value)    }    constructor (value) {        this._value = value    }    map(fn) {        return Right.of(fn(this._value))    }}// try// 用JSON.parse的异常来制造错误function parseJSON (str) {  try {    return Right.of(JSON.parse(str))  } catch (e) {    return Left.of({ error: e.message }) // 走到错误里，就把错误信息返给left，所以left的map直接return this就够了  }}let r = parseJSON('{ name: zs }') // 不给name加双引号，所以会报错console.log(r)// =>{_value: {error: "Unexpected token n in JSON at position 2"}}

没有代码报错，且把异常信息通过函子展示出来了

=======分隔符======

之后还有IO函子，Monad函子等，这玩意我是真看不懂了，能力有限啊，我知道大家看到函子这里会很蒙，我也是，其实起因在于不知道在哪里应用，不用担心，我们平时用到的机会少之又少，包括面向对象编程，我们用过么，我也就封装过少量基础的库的时候用过，所以没关系，慢慢来（安慰自己）
++++

除了最后剩的几个函子外，函数式编程圆满了！

附录

函数式编程指北
函数式编程入门