什么是函数式编程
简单说，"函数式编程"是一种"编程模型"（programming paradigm），也就是如何编写程序的方法论。
它不是一种框架，维基百科的定义是：
函数式编程[Functional Programming]是一种编程模型，他将计算机运算看做是数学中函数的计算，并且避免了状态以及变量的概念
我们在大学里面学的或者工作中使用的最多的是面向对象的编程，再往前推也使用过面向过程编程。说到函数式编程大家感觉都是一些晦涩难懂的数学函数，首先声明函数式编程不是用函数编程。
初中课本怎么定义函数呢？
在某一个过程中有两个变量x,y，当x在某一个范围内取一个值时，y都有唯一的值和他对应，这时，我们说x是自变量，y是x的函数（或因变量）。
例如：
一次函数：y = 2x
复合函数：
y = f(g(x))
g(x) = x*x
f(x) = 2x + 3
用程序来描述一次函数
const y = function (x){
return x * 2
}
用程序来描述复合函数
function A(func){
return func
}
function B(x){
return x * x
}
function C(x){
return 2 * x + c
}
const y = function(C){
return C(B)
}
这就是一个简单的把数学公式转换为程序编程的简单例子
从数学函数得到的启发是
把运算过程尽量写成一系列嵌套函数
举个例子：
(1 + 2) * 3 - 4
传统的过程式编程，可能这样写：
- var a = 1 + 2;
- var b = a * 3;
- var c = b - 4;
使用函数式编程，我们可以把运算过程定义为不同的函数，然后写成下面这样：
var result = subtract(multiply(add(1,2), 3), 4);
这就是简单的函数式编程
常见的编程范式
函数式编程是一种编程范式，我们常见的编程范式有：
- 命令式编程(Imperative programming)
命令式编程的主要思想是关注计算机执行的步骤，即一步一步告诉计算机先做什么再做什么。
比如：如果你想在一个数字集合 collection(变量名) 中筛选大于 5 的数字，你需要这样告诉计算机：
第一步，创建一个存储结果的集合变量 results；
第二步，遍历这个数字集合 collection；
第三步：一个一个地判断每个数字是不是大于 5，如果是就将这个数字添加到结果集合变量 results 中。
我们大学学习的C语言就是命令式的
- 面向对象
是目前最常见的编程范式了（绝大部分的工程项目的语言都会是面向对象语言）。而面向对象的思想则更接近于现实世界，封装好的对象之间通过消息互相传递信息。面向对象有一些我们熟悉的概念比如封装，继承，多态等等。而面向对象的思维主要是通过抽象成包含状态和一些方法的对象来解决问题，可以通过继承关系复用一些方法和行为。
- 函数式编程(Functional）
函数式编程的特性
- 函数是"第一等公民"
MDN上对JavaScript的定义部分是这样写的：
JavaScript (JS) is a lightweight interpreted or JIT-compiled programming language with first-class functions. While it is most well-known as the scripting language for Web pages, many non-browser environments also use it, such as Node.js, Apache CouchDB and Adobe Acrobat. JavaScript is a prototype-based, multi-paradigm, dynamic language, supporting object-oriented, imperative, and declarative (e.g. functional programming) styles. Read more about JavaScript.
开篇定义中便提到了函数优先（First-class Function），也即通常所说的JavaScript中的一等公民Funciton。
函数表达式:
function [name]([param] [, param] [..., param]) { statements }
两种常见使用方式：
自运行匿名函数
(function() {
// everything
}())
匿名函数赋值
var func = function() {}
var sum = function(x,y){
return x + y;
};
//检测下js中函数的类型
console.log(typeof sum) //----function
console.log(sum instanceof Object) ?
const add = function(x,y){
return x + y;
};
const mul = function(x,y){
return x * y;
};
//基本运算的通用方法
//fun 传入的函数，指明进行的运算
//x,y要进行运算的数字
const cal = function(fun,x,y){
return fun.apply(this,[x,y]);
//return fun.apply(this,arguments);也可以
};
console.log(cal(add,1,2))
console.log(cal(mul,1,2))
- 纯函数
纯函数是这样一种函数，即相同的输入，永远会得到相同的输出，而且没有任何可观察的副作用。
相同的输入，永远会得到相同的输出，通常意味着对外部状态解耦。
所谓外部状态，最常见的例子就是this，如果你的函数是：
function(){
return 'hello, ' + this.name；
}
你永远不知道this.name会被谁改写,测试用例也不可能覆盖所有情况，这种情况下出现bug的几率机会增大。
提倡函数式编程的人认为，这种共享状态导致的混乱是绝大多数bug的万恶之源
function(name){
return 'hello, ' + name；
}
- 函数的柯里化
函数柯里化（curry）的定义很简单：传递给函数一部分参数来调用它，让它返回一个函数去处理剩下的参数。
比如对于加法函数 var add = (x, y) => x + y ，我们可以这样进行柯里化：
//比较容易读懂的ES5写法
var add = function(x){
return function(y){
return x + y
}
}
//ES6写法，也是比较正统的函数式写法
var add = x => y => x + y;
var add2 = add(2);
var add100 = add(100);
add2(2); // =>4
add100(50); // =>150
事实上柯里化是将接收多个参数的函数转换为一系列只接收一个参数的函数的过程
import { curry } from 'lodash';
//首先柯里化两个纯函数
var match = curry((reg, str) => str.match(reg));
var filter = curry((f, arr) => arr.filter(f));
//判断字符串里有没有空格
var haveSpace = match(/\s+/g);
haveSpace("ffffffff");
//=>null
haveSpace("a b");
//=>[" "]
filter(haveSpace, ["abcdefg", "Hello World"]);
//=>["Hello world"]
- 代码组合（compose）
函数组合(compose)
var compose = function(f,g) {
return function(x) {
return f(g(x));
};
};
f 和 g 都是函数，x 是在它们之间通过“管道”传输的值。
var toUpperCase = function(x) { return x.toUpperCase(); };
var exclaim = function(x) { return x + '!'; };
var shout = compose(exclaim, toUpperCase);
shout("send in the clowns");
在 compose 的定义中，g 将先于 f 执行，因此就创建了一个从右到左的数据流
常见的函数式操作及实现
- 映射map
map操作队对原集合的每个元素执行给定的元素，从而变成一个新的集合。一般来说，如果需要变换一个集合的时候，就用map。以下代码为map的简单实现
function map (obj, callback) {
const results = []
if (obj === undefined || obj === null) {
return results
}
if (typeof obj.map === 'function') {
return obj.map(callback)
}
const keys = Object.keys(obj)
const length = (keys || obj).length
for (let i = 0; i < length; i++) {
results[i] = callback(obj[keys[i]], keys[i], obj)
}
return results
}
export default map
- filter
filter是根据用户定义的条件来筛选列表中的条目，并由此产生一个较小的新列表，在需要根据筛选条件来产生一个子集合的时候使用，代码实现如下：
function filter (obj, callback, context) {
if (obj === undefined || obj === null) {
throw new TypeError('obj cannot be undefined or null')
}
if (typeof callback !== 'function') {
throw new TypeError('callback should be function')
}
const keys = Object.keys(obj)
const length = (keys || obj).length
const ret = []
for (let i = 0; i < length; i++) {
if (callback.call(context, obj[keys[i]], keys[i], obj)) {
ret.push(obj[keys[i]])
}
}
return ret
}
export default filter
小结
- 代码简洁，开发快速
函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。
- 可测试
我们发现，当函数功能变的单一的时候，我们可以很清晰的知道函数输入什么，输出什么的时候，我们发现，这个代码的可测试性，得到了很大的提高。还是用上面的两段代码，前者，根本不知道怎么去写测试，或者说，就是错了，你也不知道哪里错的，因为，所有的逻辑被各种匿名函数包裹了，很难很快的定位到问题的所在，后者，则容易了很多。
待补充。。。
