函数式编程（四）

函子（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 right
class 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函子等，这玩意我是真看不懂了，能力有限啊，我知道大家看到函子这里会很蒙，我也是，其实原因在于不知道在哪里应用，不用担心，我们平常用到的机会少之又少，包括面向对象编程，我们用过么，我也就封装过一些基础的库的时候用过，所以没关系，慢慢来（安慰自己）
++++

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

附录

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