Part1 · JavaScript【深度剖析】
函数式编程与Js异步编程、手写Promise
文章说明：本专栏内容为本人参加【拉钩大前端高新训练营】的学习笔记以及思考总结，学徒之心，仅为分享。如若有误，请在评论区支出，如果您觉得专栏内容还不错，请点赞、关注、评论。
共同进步！
上一篇：【纯函数】、【柯里化】、【函数组合】
下一篇：【JavaScript异步编程】
前情提要：
上一篇中提到了【纯函数】、【柯里化】、【函数组合】，点击上方链接可查看。
文章目录
七、Functor（函子）
1.为什么要学函子
到目前为止已经已经学习了函数式编程的一些基础，但是我们还没有演示在函数式编程中如何把副作用
控制在可控的范围内、异常处理、异步操作等。
2.什么是Functor
- 容器：包含值和值的变形关系(这个变形关系就是函数)
- 函子：是一个特殊的容器，通过一个普通的对象来实现，该对象具有 map 方法，map 方法可以运
行一个函数对值进行处理(变形关系)
3.Functor函子
// ES6中引入类的概念，但是js中没有一个真正的class原始类型，仅仅只是对原型对象运用【语法糖】，所
// 以只有理解如何使用原型对象实现类和继承，才能真正的用好
class Container {
// 实现of静态方法，不用每次都调用new Container创建对象
static of(value) {
return new Container(value)
}
// 创建构造函数，将传入的value值包含在容器内部（不对外展示）
constructor(value) {
// _开头的变量一般定义为内部属性
// 通常变量前加下划线表示“私有变量”。函数名前加下划线表示“私有函数”。
this._value = value
}
// 向外部抛出map函数，用于接收处理value的方法
map(fn) {
return Container.of(fn(this._value))
}
}
// 测试
let r = Container.of(3)
.map(x => x + 2)
.map(x => x * x)
console.log(r)
// ==>Container { _value: 25 }
-
总结
- 函数式编程的运算不直接操作值，而是由函子完成
- 函子就是一个实现了map契约的对象
- 我们可以把函子想象成一个盒子，盒子内部封装一个值（value），不对外公布
- 想要处理盒子中的值，我们需要给盒子的map方法传递一个处理值得函数（纯函数），由这个函数来对值进行处理
- 最终map方法返回一个包含新值得盒子（函子），多次调用map方法，会形成函子嵌套
-
在Functor中如果传入空值（副作用）
Container.of(null)
.map(x => x.toUpperCase())
// TypeError: cannot read property 'toUpperCase' of null
4.MayBe函子
- 我们在编程的过程中可能会遇到很多错误，需要对这些错误做相应的处理
- MayBe函子的作用就是可以对外部的空值情况做处理（控制副作用在允许的范围）
class MayBe {
static of(value) {
return new MayBe(value)
}
constructor(value) {
this._value = value
}
isNothing() {
return this._value === null || this._value === undefined
}
// 如果对空值变形的话直接返回【值为null的函子】
map(fn) {
return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this._value))
}
}
// 传入具体值
let r1 = MayBe.of('Hello world')
.map(x => x.toUpperCase())
console.log(r1) // MayBe { _value: 'HELLO WORLD' }
// 传入null的情况
let r2 = MayBe.of(null)
.map(x => x.toUpperCase())
console.log(r2) // MayBe { _value: null }
- 在MayBe函子中，我们很难确认是哪一步产生的空值问题，如下例：
MayBe.of('hello world')
.map(x => x.toUpperCase())
.map(x => null)
.map(x => x.split(' '))
// => MayBe { _value: null }
5.Either函子
- 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))
}
}
- Either用来处理异常
function parseJSON(json) {
try {
return Right.of(JSON.parse(json));
} catch (e) {
return Left.of({error: e.message});
}
}
let r = parseJSON('{ "name": "zs" }')
.map(x => x.name.toUpperCase())
console.log(r) // Right { _value: 'ZS' }
6.IO函子
- IO函子中的_value是一个函数，这里是把函数作为值来处理
- IO函子可以把不纯的动作储存到_value中，延迟执行这个不纯的操作（惰性执行），包装当前的操作
- 把不纯的操作交给调用者来处理
const fs = require('lodash/fp')
class IO {
static of(x) {
return new IO(function () {
return x
})
}
constructor(fn) {
this._value = fn
}
map(fn) {
// 把当前的value和传入的fn函数组合成一个新的函数
return new IO(fp.flowRight(fn, this._value))
}
}
// 调用
let io = IO.of(process)
.map(p => p.execPath)
console.log(io._value) //
7.Task异步执行
-
异步任务的实现过于复杂，我们使用folktale中的Task来演示
-
folktale是一个标准的函数编程库
- 和 lodash、ramda 不同的是，他没有提供很多功能函数
- 只提供了一些函数式处理的操作，例如：compose、curry 等，一些函子 Task、Either、
MayBe 等
const {compose, curry} = require('folktale/core/lambda')
const {toUpper, first} = require('lodash/fp')
// 第一个参数是传入函数的参数个数
let f = curry(2, function (x, y) {
console.log(x + y)
})
f(3, 4)
f(3)(4)
// 7
// 7
// 函数组合
let r = compose(toUpper, first)
f(['one', 'two'])
console.log(r)
// [function]
-
Task 异步执行
- folktale(2.3.2) 2.x 中的 Task 和 1.0 中的 Task 区别很大，1.0 中的用法更接近我们现在演示的函子
- 这里以 2.3.2 来演示
const {task} = require('folktale/concurrency/task')
const fs = require('fs')
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)
})
})
}
// 调用run执行
readFile('package.json')
.map(split('\n'))
.map(find(x => x.includes('version')))
.run().listen({
onRejected: err => {
console.log(err)
},
onResolved: value => {
console.log(value)
}
})
8.Pointed函子
- Pointed函子是实现了of静态方法的函子
- of方法是为了避免使用new来创建对象，更深层的韩一是of方法用来把值放到上下文Context（把值放到容器中，使用map来处理值）
class Container {
static of (value) {
return new Container(value)
}
……
}
Contanier.of(2)
.map(x => x + 5)
9.Monad（单子）
在使用IO函子的时候，如果出现了以下代码：
const fs = require('fs')
const fp = require('lodash/fp')
class IO {
static of(x) {
return new IO(function () {
return x
})
}
constructor(fn) {
this._value = fn
}
map(fn) {
// 把当前的value和传入的fn函数组合成一个新的函数
return new IO(fp.flowRight(fn, this._value))
}
}
let readFile = function (filename) {
return new IO(function () {
return fs.readFileSync(filename, 'utf-8')
})
}
let print = function (x) {
return new IO(function () {
console.log(x)
return x
})
}
let cat = fp.flowRight(print, readFile)
// 调用
let r = cat('package.json')._value()._value()
console.log(r)
- Monad函子是可以变变得Pointed函子，IO(IO(x))
- 一个函子如果具有join和of两个方法并遵守一些定律就是一个Monad
// IO Monad
class IO {
static of(x) {
return new IO(function () {
return x
})
}
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 r = readFile('package.json')
.map(fp.toUpper)
.flatMap(print)
.join()
八、附录
总结
前面三张总结了函数式编程的一些基础，接下来开始学习异步编程
往期回顾：
