Step 1 课程介绍

课程背景：

前端的主要编程语言为 JavaScript。
JavaScript 作为一种融合了多种编程范式的语言，灵活性非常高。
前端开发人员根据场景在不同编程范式间自如切换。
进一步需要创造领域特定语言抽象业务问题。

课程收益：

了解不同编程范式的起源和适用场景。
火葬我JavaScript 在不同的编程范式特别是函数式编程范式的使用。
掌握创建领域特定语言的相关工具和模式。

Step 2 编程语言

机器语言 -> 汇编语言 -> 高级语言

C语言

面向过程语言对位、字节、地址直接进行操作
可移植能力强

C/C++

面向对象语言代表
C with Classes
继承
权限控制
虚函数
多态

Lisp

函数式语言
与机器无关
列表：代码即数据
闭包

JavaScript

基于原型和头等函数的多范式语言
过程式
面向对象
函数式
响应式

总结

Step 3 编程范式

什么是编程范式

程序语言特性：

是否允许副作用
操作的执行顺序
代码组织
状态管理
语法和词法

常见编程范式

编程范式：

命令式
- 面向过程
- 面向对象
声明式
- 函数式
- 响应式

过程式编程

自顶向下

结构化编程

面向过程问题

数据和算法关联弱

不利于修改和扩充

不利于代码重用

面向对象

特性：

封装
- 将数据和算法封装成一个个的类，让数据和算法之间互相联系，使得代码可读性更高
继承
- 继承可以使一个类拥有另一个类的所有算法和数据，并且在这一基础上进行功能扩充
多态
- 一个类实例相同的方法在不同的使用情形下具有不同的表现形式，即将使用的权限交给对象，对象根据具体的情形来选择不同的方法，最终达到函数复用的效果。
依赖注入*
- 在程序运行过程中，需要使用另一个对象时，无需在代码中创建及初始化，而是依赖于外部的注入，用来降低代码的耦合度。

面向对象五大原则

单一职责原则SRPSingle Responsibility Principle
开放封闭原则OCPOpen - Close Principle
里氏替换原则LSPthe Liskov Substitution Principle
依赖倒置原则DIPthe Dependency Inversion Principle
接口分离原则ISPthe Interface Segregation Principle

面向对象的缺点通过类来封装功能，但是我们有时候只需要类的一部分功能，但我们不能避免的把整个类都挪用。

函数式编程

特点：

函数是第一等公民
纯函数/无副作用
高阶函数/闭包

First Class Function

如果没有一等函数，那么在某些情况下代码的编写就会比较麻烦，例如下面的聚合转发：

const BlogController = {
    index(posts) { return Views.index(posts); }
    show(post) { return Views.show(post); }
    create(attrs) { return Db.create(attrs); }
    update(post,attrs) {return Db.update(post,attrs); }
    destroy(post) {return Db.destroy(post); }
};

而当我们拥有了一等函数之后，这类转发功能就可以像基本数据类型一样直接传回封装的API

const BlogController = {
    index: Views.index,
    show: Views.show,
    create: Db.create,
    update: Db.update,
    destroy: Db.destroy,    
};

Pure Function

优势
- 可缓存
- 可移植
- 可测试
- 可推理
- 可并行这种纯函数是不依赖于外部环境，并且不改变外部环境例如：

const retireAge = 60;
function retirePerson(p) {
    if (p.age > retireAge) {
        p.status = 'retired';
    }
}

由于retireAge由函数外部定义，所以该函数会随外部环境变化，因此优化为纯函数之后如下

function retirePerson(p) {
    const retireAge = 60;
    if (p.age > retireAge){
        return {
         ...p,
         status: 'retired',
        };
    }
    return p;
}

Currying

咖喱化 可以将一些固定的参数预先封装在需要的函数中，然后等我们要使用该函数时，只需要传入剩下的参数即可。

Currying使用了函数式编程闭包的特性，即返回一个预存了参数的函数，当调用返回的函数时，会将传入的参数和预存的参数组合起来调用函数。

Composition `组合`

手动组合：

const toUpperCase = x => x.toUpperCase();
const log = console.log;

function alertUpperCase(s) {
    log(toUpperCase(s));
}

灵活性很差

自动组合：

const alertUppercaseFn = compose(log,toUpperCase);

参数会从右至左经过函数并且将返回结果传递给alertUppercaseFn

compose 内部

const compose = (...fns) => (...args) => fns.reduceRight(
    (res,fn) => [fn.call(null,...res)],args
)[0];

compose内部是通过高阶函数将函数从右到左的进行组合

组合支持一些等价的函数式 compose(f,compose(g,h)) === compose(compose(f,g),h) 对于map方法 => compose(map(f),map(g)) === map(compose(f,g))

Functor

可以当作容器的类型，类型支持对容器内元素进行操作

常见的functor：Array(Iterable).map、Promise.then

当我们需要对对象里面的属性是否不存在而需要进行判断时，我们可以将这种判断封装到容器里面去

Monad

可以去除嵌套容器的容器类型

常见的monad：Array.faltMap、Promise.then

Applicative

如果容器不支持对两个容器同时操作的话，我们需要将容器里面的元素取出，然后再对另外一个容器进行操作，操作完成之后必须进行打平，不然会出现嵌套容器

new Maybe(2).map(two =>
    new Maybe(3).map(add(two))
).flat();

如果支持Applicative

new Maybe(add)
    .ap(new Maybe(3))
    .ap(new Maybe(2));

ap的实现

ap(other) {
    return other.map(this.$value);
}

ap支持的数学规则

Maybe(id).ap(v) === v

Maybe(f).ap(Maybe(x)) === Maybe(f(x))

v.ap(Maybe(x)) = Maybe(f => f(x)).ap(v)

Maybe(Compose).ap(u).ap()v.ap(w) === u.ap(v.ap(w))