函数式编程、JS异步及promise

最新推荐文章于 2023-06-30 20:08:57 发布

由良时雨

最新推荐文章于 2023-06-30 20:08:57 发布

阅读量626

点赞数

分类专栏： js

本文链接：https://blog.csdn.net/weixin_45444401/article/details/115520352

版权

js 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

函数式编程

什么是函数式编程

函数式编程随着React的流行收到越来越多的关注，Vue3也开始拥抱函数式编程

函数式编程可以抛弃this

打包过程中可以更好的利用tree shaking过滤无用代码

方便测试、方便并行处理

有很多库可以帮助我们进行函数式开发：loadsh、underscore、ramda

函数式编程是编程范式之一

面向对象编程的思维方式：把现实中的事物抽象成程序世界中的类和对象，通过封装、继承和多态来演示事物事件的联系；

函数式编程的思维方式：把现实中事物和事物之间的联系抽象到程序世界（对运算过程进行抽象）

程序的本质：根据输入通过某种运算获得相应的输出，程序开发过程中涉及到很多有输入和输出的函数
函数式编程中的函数指的不是程序中的函数（方法），而是数学中的函数即映射关系
相同的输入始终要得到相同的输出（纯函数）
函数时编程用来描述数据（函数）之间的映射

函数是一等公民

函数可以存储在变量中
函数作为参数
函数作为返回值
在js中函数就是一个普通的对象

高阶函数

可以把函数作为参数传递给另一个函数
可以把函数作为另一个函数的返回结果

使用高阶函数的意义

抽象可以帮我们屏蔽细节，只需要我们关注我们的目标

高阶函数是用来抽象通用的问题

常用的高阶函数

forEach
map
filter
every
some
find/findIndex
reduce
sort

闭包

函数和其周围的状态的引用捆绑在一起形成闭包
可以在另一个作用域中调用一个函数的内部函数并访问到该函数的作用域中的成员
闭包的本质：函数在执行的时候会放到一个执行栈上当函数执行完毕之后会从执行栈上移除，但是堆上的作用域成员因为被外部引用不能释放，因此内部函数依然可以访问外部函数的成员

纯函数

纯函数：相同的输入永远会得到相同的输出
lodash是一个纯函数的功能库，提供了对数组、数字、对象、字符串、函数等操作的一些方法
数组的slice和splice分别是纯函数和不纯的函数

纯函数的好处

可缓存

因为纯函数对相同的输入始终有相同的结果，所以可以把纯函数的结果缓存起来
测试更方便
在多线程环境下并行操作共享的内存数据很可能出现意外；纯函数不需要访问共享的内存数据，所以在并行环境下可以任意运行纯函数

副作用

纯函数的根据相同的输入返回相同的输出，如果函数依赖于外部的状态就无法保证输出相同，就会带来副作用。

柯里化

当一个函数有多个参数的时候先传递一部分参数调用它（这部分参数以后永远不变）
然后返回一个新的函数接收剩余的参数，返回结果

function checkAge (age) {
 let min = 18
 return age >= min
}
// 普通纯函数
function checkAge (min, age) {
 return age >= min
}
checkAge(18, 24)
checkAge(18, 20)
checkAge(20, 30)
// 柯里化
function checkAge (min) {
 return function (age) {
  return age >= min
}
}
// ES6 写法
let checkAge = min => (age => age >= min)
let checkAge18 = checkAge(18)
let checkAge20 = checkAge(20)
checkAge18(24)
checkAge18(20)

lodash中的柯里化函数

_.curry(func)

功能-创建一个，该函数接收一个或多个func的参数，如果func所需要的参数都被提供则执行func并返回执行结果。否则继续返回该函数并等待接收剩余的参数。

参数：需要柯里化的函数

返回值：柯里化后的函数

组合函数

纯函数和和柯里化很容易写出洋葱代码h(g(f(x)))
函数组合可以让我们把l细粒度的函数重新组合生成一个新的函数

函数组合：如果一个函数要经过多个函数处理才能得到最终值，这个时候可以把中间过程的函数合并成一个函数

函数组合默认从右到左执行

lodash中的组合函数
lodash中的组合函数flow()或者flowRight(),他们都可以组合多个函数
flow()是从左到右
flowRight()是从右到左运行，使用的更多一些

函数的组合要满足结合律

我们既可以把g和h组合，还可以把f和g组合，结果都是一样的

Point Free

我们可以把数据处理的过程定义成与数据无关的合成运算，不需要用到代表数据的那个参数，只要把简单的运算步骤合成到一起，在使用这种模式之前我们需要定义一些辅助的基本运算函数。

不需要指明处理的数据
只需要合成运算过程
需要定义一些辅助的基本运算函数

// 非 Point Free 模式
// Hello World => hello_world
function f (word) {
 return word.toLowerCase().replace(/\s+/g, '_');
}
// Point Free
const fp = require('lodash/fp')
const f = fp.flowRight(fp.replace(/\s+/g, '_'), fp.toLower)
console.log(f('Hello World'))

Functor(函子）

容器：包含值和值的关系
函子：是一个特殊的容器，通过一个普通的对象来实现，该对象具有map方法，map方法可以运行一个函数对值进行处理

总结

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

MayBe 函子

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

Either 函子

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

IO 函子

IO 函子中的 _value 是一个函数，这里是把函数作为值来处理
IO 函子可以把不纯的动作存储到 _value 中，延迟执行这个不纯的操作(惰性执行)，包装当前的操作纯
把不纯的操作交给调用者来处理

Task 异步执行

异步任务的实现过于复杂，我们使用 folktale 中的 Task 来演示
folktale 一个标准的函数式编程库
和 lodash、ramda 不同的是，他没有提供很多功能函数
只提供了一些函数式处理的操作，例如：compose、curry 等，一些函子 Task、Either、MayBe 等

pointed函子

pointed函子是实现了of静态方法的函子
of方法是为了避免使用new来创建对象，更深层的含义是of方法用来把值放到上下文Context（把值放到容器中，使用map来处理值）

monad（单子）

monad是可以变扁的pointed函子
一个函子如果具有join和of 两个方法并遵守一定的规律就是一个Monad

const fs = require('fs')
const fp = require('lodash/fp')
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
})
}
Functors, Applicatives, And Monads In Pictures
// IO(IO(x))
let cat = fp.flowRight(print, readFile)
// 调用
let r = cat('package.json')._value()._value()
console.log(r)

const fp = require('lodash/fp')
// 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()