1、函数式编程思维

函数式编程，是用数学思维编程
（1）起源于范畴论，彼此之间存在某种关系的概念、事物、对象等等，都构成“范畴”。只要能找到他们之间存在的关系，就能定义一个范畴。
（2）而他们之间的这种关系，叫做“态射”，同一个范畴的成员，通过态射，可以便形成另一个成员。
（2）一个成员变形成另一个成员，这种变形关系，可以抽象出数学模型，
·所有成员是一个集合
·变形关系是函数
（3）使用函数来表达范畴之间的关系。函数是一种数学运算，用这种函数运算方法和思维用来编写程序，就是函数式编程
（4）既函数式编程的基础模型来源于数学演算，

2、函数式编程基础理论

函数式编程不是用函数来编程，主旨在于将复杂的函数复合成简单的函数，运算过程尽量写成一系列嵌套的函数调用。
函数式编程特点

（1）函数式“第一等公民”

所谓“第一公民”，指的是函数与其他数据类型一样，处于平等地位，可以赋值给其他变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值。

（2）只用“表达式”，不用“语句”

“表达式”是一个单纯的运算过程，总是有返回值；“语句”是执行某种操作，没有返回值。函数式编程要求，只使用表达式，不使用语句。也就是说，每一步都是单纯的运算，而且都有返回值。

（3）没有“副作用”

所谓“副作用”，指的是函数内部与外部互动，产生运算以外的其他结果。函数式编程强调没有“副作用”，意味着，函数要保持独立，没有其他行为，尤其是不得修改外部变量的值。

（4）不修改状态

上一点提到，不能修改变量，那么状态就不能保存在变量中。函数式编程使用参数保存状态，例如递归。

（5）引用透明

也就是说，函数的运行不依赖于外部变量或者“状态”，只依赖于输入的参数，任何时候只要参数相同，引用函数所得到的返回值总是相同的。

3.纯函数

对于相同的输入，永远会得到相同的输出，而且么有任何可观察的副作用，也不依赖外部环境状态。
例如：

var a = [1,2,3,4,5];

a.slice(0,3);//[1,2,3]
a.slice(0,3);//[1,2,3]

Array.slice是纯函数，因为他没有副作用，固定的输入，输出都是固定的。

a.splice(0,3);//[1,2,3]
a.splice(0,3);//[4,5]

但是Array.splice不是纯函数，因为它有副作用，改变了原函数，当再次输入相同时，输出改变了。固定的输入，输出不固定。

import _ from 'lodash';
var sin = _.memorize(x => Math.sin(x));
//第一次计算的时候会稍慢一些
var a = sin(1);
//第二次有了缓存，会极快
var b = sin(1);
//memorize函数的实现，lodash实现了很好的封装

纯函数不仅可以有效的降低系统的复杂度，还有很多很棒的特性，比如可缓存性。

//不纯的
var min = 18;
var checkage = age => age > min;

//纯的,这很函数式
var checkage = age => age > 18;

很明显，不纯的版本中，checkage不仅取决于age，还取决于外部以来的变量min。
但是，纯的checkage把关键数字18硬编码在函数内部，扩展性很差柯里化优雅的函数式解决了这个问题。

4.函数的柯里化

传递给函数一部分的参数来调用它，让它返回一个函数去处理剩下的参数。
🌰举个例子，展示函数的柯里化code

//柯里化之前
function add(x,y){
  return x+y;
}
add(1,2);//3
//柯里化之后
function addX(y){
  return function(x){
      return x+y;
  };
}
addX(2)(1);//3
//es6的写法
var addX = (y => (x => x+y));

🌰用柯里化来改checkage

var checkage = min => (age => age>min);
var checkage18 = checkage(18);//返回一个函数age=>age>min
checkage(20);//true,20>18

🌰

import {curry} from 'lodash';
//把函数进行柯里化
var match = curry((reg,str) => str.match(reg));
var filter = curry((f,arr) => arr.filter(f));
haveSpace = match(/\s+/g);
filter(haveSpace)(['asdfa','Hello world']);

//以上柯里化，类似之前的addX
function(f){
  return function(arr){
    arr.filter(f);
  }
}

事实上，柯里化是一种“预加载”函数的方法，通过传递较少的参数，得到一个已经记住了这些参数的新函数，某种意义上讲，这是一种对参数的“缓存”，是一种非常高效的编写函数的方法。

5.函数的组合

纯函数以及函数的柯里化，写出了洋葱代码h(g(f(x)))，为了解决函数嵌套这种“不优雅”的问题，我们需要用到函数组合。

const compose = (f,g) => (x => f(g(x)));
var first = arr => arr[0];//返回第一个元素
var reverse = arr => arr.reverse();//返回数组元素颠倒后数组
var last = compose(first,reverse);
last([1,2,3,4,5]);//5`

函数的组合知识对代码进行了包装,内部进行了折腾，暴露出来一个compose，其实内部的实现还是洋葱代码的实现。

6.Point Free

把一些对象自带的方法转化成纯函数，不要命名转瞬即逝的中间变量。
🌰

const f = str => str.toUpperCase().splite(' ');

这个函数我们使用了str作为中间变量，但是这个中间变量除了让代码变得更长了一儿以外是毫无意义的。
🌰

var toUpperCase = world => world.toUpperCase();
var split = x => (str => str.split(x));

var f = compose(split(' '),toUpperCase);
f("abcd efgh");

来写一下上面的代码转换

//const compose = (f,g) => (x => f(g(x)));
const comspose = function(f,g){
        //split(' ') str => str.split(' ')   
        //toUpperCase
        return function(x){
                return f(g(x));
        }
}
var toUpperCase = world => world.toUpperCase();
var split = x => (str => str.split(x));
var f = compose(split(' '),toUpperCase);
f("abcd efgh");

这种风格能够帮助我们减少不必要的命名，让代码保持简洁和通用。

7.声明式与命令式代码

       命令式代码的意思就是，我们通过编写一条又一条指令去让计算机执行一些动作，这其中一般都会涉及到很多繁杂的细节。
而声明式代码就要优雅很多了，我们通过写表达式的方式来声明我们想干什么，而不是通过一步步的指示。
🌰

//命令式
let CEOs = [];
for (var i = 0; i<companies.length; i++){
    CEOs.push(companies[i].CEO);
}
//声明式
let CEOs = companies.map(c => c.CEO);//map是个纯函数

优缺点：
       函数式编程的一个明显的好处就是这种声明式代码，对于无副作用的纯函数，我们完全可以不考虑函数内部是如何实现的，专注于编写业务代码。优化代码时，目光只需要集中在这些稳定坚固的函数内部即可。
       相反，不纯的函数式的代码会产生副作用或者依赖外部系统环境，使用它们的时候总是要考虑这些不干净的副作用。在复杂的系统中，这对于程序员的心智来说是极大的负担。

8.惰性求值，惰性函数

惰性载入表示函数执行的分支只会在函数第一次调用的时候执行，在第一次调用过程中，该函数会被覆盖为另一个按照合适方式执行的函数，这样任何对原函数的调用就不用再经过执行的分支了。
🌰

function addEvent (type, element, fun) {
    if (element.addEventListener) {
        element.addEventListener(type, fun, false);
    }
    else if(element.attachEvent){
        element.attachEvent('on' + type, fun);
    }
    else{
        element['on' + type] = fun;
    }
}

重写之后

function addEvent (type, element, fun) {
    if (element.addEventListener) {
        addEvent = function (type, element, fun) {
            element.addEventListener(type, fun, false);
        }
    }
    else if(element.attachEvent){
        addEvent = function (type, element, fun) {
            element.attachEvent('on' + type, fun);
        }
    }
    else{
        addEvent = function (type, element, fun) {
            element['on' + type] = fun;
        }
    }
    return addEvent(type, element, fun);
}

由上，第一次调用addEvent会对浏览器做能力检测，然后，重写了addEvent。下次再调用的时候，由于函数被重写，不会再做能力检测。
惰性函数定义应用还体现在创建单例上

unction Universe() {

    // 缓存的实例
    var instance = this;

    // 其它内容
    this.start_time = 0;
    this.bang = "Big";

    // 重写构造函数
    Universe = function () {
        return instance;
    };
}