前言
学习笔记输出~
内容
Functor(函子)
什么是函子
容器: 包含值和值的变形关系(函数)
函子: 是一个特殊的容器,通过一个普通的对象来实现,该对象具有map方法,map方法可以运行一个函数对值进行处理(变形关系)
代码演示
代码
代码改造
函数式编程思想避免直接看到new操作,所以对new进行封装
class Container { static of(value) { return new Container(value) } constructor(value) { this._value = value } map(fn) { return Container.of(fn(this._value)) } } let r = Container.of(4).map(x => x++).map(x => x * x) console.log(r) // => Container { _value: 16 }
总结
- 函数式编程的运算不直接操作值,而是由函子完成
- 函子就是一个实现了map契约的对象
- 我们可以把函子想象成一个盒子,盒子里封装了一个值
- 想要处理盒子中的值,我们要给盒子的map方法传递一个处理值得函数(纯函数),由这个函数对值进行处理
- 最终map方法返回一个包含新值得盒子(函子)
MayBe
MayBe函子的作用就是可以对外部的空值情况做处理(控制副作用在允许的范围)
class MayBe { static of(value) { return new MayBe(value) } constructor(value) { this._value = value } map(fn) { return this.isNothing() ? MayBe.of(null) : MayBe.of(this._value) } isNothing() { return this._value === null || this._value === undefined } } let r = MayBe.of(null).map(x => x.toUpperCase()) console.log(r)
Either
类似于if..else..的处理,异常会让函数变的不纯,Either函子可以用来做异常处理
class Left { static of(value) { return new Left(value) } constructor(value) { this._value = value } map(fn) { return this } } class Right { static of(value) { return new Right(value) } constructor(value) { this._value = value } map(fn) { return Right.of(fn(this._value)) } } // let r1 = Right.of(12).map(x => x + 2) // let r2 = Left.of(12).map(x => x + 2) // console.log(r1, r2) function parseJSON (str) { try { return Right.of(JSON.parse(str)) } catch (e) { return Left.of({error: e.message}) } } let r1 = parseJSON('{name: ts}') console.log(r1) let r2 = parseJSON('{"name": "ts"}').map(x => x.name.toUpperCase()) console.log(r2)
IO
IO函子中的_value是一个函数,这里将函数作为值来处理
IO函子可以把不纯的动作存储到_value中,延迟执行这个不纯的操作(惰性执行),保证当前的操作都是纯函数
把不纯的操作交给调用者来处理
const fp = require('lodash/fp') class IO { static of(value) { return new IO(function () { return value }) } constructor(value) { this._value = value } map(fn) { return new IO(fp.flowRight(fn, this._value)) } } let r = IO.of(process).map(p => p.execPath) // console.log(r) console.log(r._value())
Task
https://folktale.origamitower.com/
Task函子可以帮我们控制副作用进行异常处理，还可以处理异步任务，因为异步任务会带来回调地狱问题，使用Task函子可以避免出现回调的嵌套;
const fs = require('fs') const { task } = require('folktale/concurrency/task') const { split, find } = require('lodash/fp') function readFile(fileName) { return task(resolver => { fs.readFile(fileName, 'utf-8', (err, data) => { if (err) resolver.reject(err) resolver.resolve(data) }) }) } readFile('package.json') .map(split('\n')) .map(find(x => x.includes('version'))) .run() .listen({ onRejected: err => { console.log(err) }, onResolved: value => { console.log(value) } })
Pointed
Pointed函子是实现了of静态方法的函子
of方法是为了避免使用new来创建对象,更深层的含义是of方法用来把值放到上下文Context(把值放到容器中,使用map来处理值)
class Container { static of(value) { // 返回的结果就是上下文 return new Container(value) } ...... } let r = Container.of(4) .map(x => x++) // 在上下文上处理数据
Monad
Monad函子是可以解决函子嵌套(如: IO(IO(x)))的Pointed函子
一个函子如果具有join和of两个方法并遵守一些定律就是一个Monad
const fp = require('lodash/fp') const fs = require('fs') const { log } = require('console') class IO { static of(value) { return new IO(function () { return value }) } constructor(fn) { this._value = fn } map(fn) { return new IO(fp.flowRight(fn, this._value)) } join() { return this._value() } flatMap(fn) { return this.map(fn).join() } } let readFile = fileName => { return new IO(() => { return fs.readFileSync(fileName, 'utf-8') }) } let print = x => { return new IO(() => { console.log(x) return x }) } let r = readFile('package.json') .map(fp.toUpper) .flatMap(print) .join() console.log(r);
学无止境,谦卑而行.
