什么是函数式编程
函数式编程（英语：functional programming），又称泛函编程，是一种编程范式，它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。
纯函数（函数式编程的基石，无副作用的函数）
对于输入x产生一个唯一输出y=f(x)
1.此函数在相同的输入值时，总是产生相同的输出。函数的输出和当前运行环境的上下文状态无关。
2.此函数运行过程不影响运行环境，也就是无副作用（如触发事件、发起http请求、打印/log等）。
特点
1.函数是"第一等公民"
函数与其他数据类型一样，处于平等地位，可以赋值给其他变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值。
const print = function(text) {
console.log(text)
}
[1,3,4].forEach(print)
- 只用"表达式"，不用"语句"
- 没有"副作用"
函数内部与外部互动（最典型的情况，就是修改全局变量的值），产生运算以外的其他结果。 - 不修改状态
函数式编程只是返回新的值，不修改系统变量。
const arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr.slice(1,0)
console.log(arr) // ["George,John"]
arr.splice(1,1)
console.log(arr) // ["George"]
- 引用透明
函数的运行不依赖于外部变量或"状态"，只依赖于输入的参数，任何时候只要参数相同，引用函数所得到的返回值总是相同的。
以下为一个非纯函数：
let minimum = 21;
const checkAge = function(age) {
return age >= minimum;
};
如何将其变为一个纯函数？
函数依赖外部变量minimum,将minimun放入函数中引用
const checkAge =(age)=> {
let minimum = 21;
return age >= minimum;
};
以上为一个纯函数，但是可以看到这样一来，checkAge函数的minimum只能判断最小值大于21的情况，限制了函数的扩展性。
将函数变形如下：
const checkAge = (age, minimum)=> {
return age >= minimum;
};
如此一来，checkAge又有了扩展性，但是输入不再是单一输入，那么久不再是一个纯函数。那么如何将这个函数进一步变成纯函数？下面介绍柯理化
函数柯里化
柯里化(curry)的概念：将一个低阶函数转换为高阶函数的过程就叫柯里化。
高阶函数：高阶函数是对其他函数进行操作的函数，可以将它们作为参数或返回它们。 简单来说，高阶函数是一个函数，它接收函数作为参数或将函数作为输出返回。
高阶函数的例子：
const arr= [1,2,3]
const arr2 = []
for(let i=0;i<arr.length;i++){
arr2.push(arr[i] * 2)
}
arr2 //[2,4,6]
const arr= [1,2,3]
const arr2 = arr.map(item => item * 2)
checkAge函数柯理化：将checkAge函数变为高阶函数
const checkAge = (age, min)=> {
return age >= min;
};
const checkAge = (age)=> {
return (min)=>{
return age >= min
}
};
//--es6简写
const checkAge = age => (min => age >= min)
checkAge(age)(min)
声明式和命令式代码
命令式代码：命令“机器”如何去做事情(how)，这样不管你想要的是什么(what)，它都会按照你的命令实现。
声明式代码：告诉“机器”你想要的是什么(what)，让机器想出如何去做(how)。
继续以上面的高阶函数举例:
//命令式
const arr= [1,2,3]
const arr2 = []
for(let i=0;i<arr.length;i++){
arr2.push(arr[i] * 2)
}
arr2 //[2,4,6]
//声明式
const arr= [1,2,3]
const arr2 = arr.map(item => item * 2)
声明式编程必须将要实现一个方法的每一步如何做的都声明写下。
函数式编程的一个明显的好处就是这种声明式的代码，对于无副作用的纯函数，我们完全可以不考虑函数内部是如何实现的，专注于编写业务代码。优化代码时，目光只需要集中在这些稳定坚固的函数内部即可。
范畴
"范畴"是满足某种变形关系的所有对象,变形关系=函数，所有对象=集合
集合 + 函数
定义一个简单范畴：
class Category {
constructor(val) {
this.val = val;
}
addOne(f) {
return new Category(this.val + 1);
}
}
Category是一个类里面包含一个值，addOne为变形关系，此范畴为所有个体值相差1的数字。
函子
函子首先是一种范畴。
变形关系-函数：不仅可以用于同一个范畴之中值的转换，还可以用于将一个范畴转成另一个范畴。
函子是函数式编程里面最重要的数据类型，也是基本的运算单位和功能单位。
左侧为一个人名的范畴，通过内部函数最爱的食物，转换成新的食物范畴。左侧就是函子。
任何具有map方法的数据结构，都可以当作函子的实现。
class Functor {
constructor(val) {
this.val = val;
}
map(f) {
return new Functor(f(this.val));
}
}
Functor即是函子，map为函子内部函数，他接受f函数作为参数，返回一个新的函子。
一般约定，函子的标志就是容器具有map方法。该方法将容器里面的每一个值，映射到另一个容器。
(new Functor(2)).map(function (two) {
return two + 2;
});
函数式编程里面的运算，都是通过函子完成，即运算不直接针对值，而是针对这个值的容器----函子。学习函数式编程，实际上就是学习函子的各种运算。
定义一个functor
通过上面的学习，将函数式编程带入项目中，通过定义函子进行运算。以下为个人举例：
//定义一个Criterion的函子
export class Criterion {
public criterion: CriterionItem[];
constructor(criterion) {
this.criterion = criterion;
}
public static of(criterion) {
return new Criterion(criterion)
}
public get() {
return this.criterion
}
public map(fn) {
return new Criterion(this.criterion.map(fn))
}
public addOne() {
const newCriterion = this.criterion.concat()
newCriterion.push(new CriterionItem())
return new Criterion(newCriterion)
}
}
of
Criterion函子中，of函数为函子键入唯一值，他不仅仅是用来省略new关键字的，同时也是一种模式，这种模式叫pointed functor，Array在es2015中也加入Array.of()，使arrays成为一个pointed functor.
通过如上代码实现了一个简单的函子，并通过其中的变形关系对函子进行计算，以实现声明式编程的。
criterionor.of(criterion).addOne().map(fun).get()
