一、弁言

说到函数式编程，人人可以第一印象都是学院派的那些艰涩难明的代码，充满了一大堆笼统的不知所云的标记，好像只要大学里的盘算机传授才会运用这些东西。在曾的某个时期可以确切云云，然则近年来跟着手艺的生长，函数式编程已在实际临盆中发挥庞大的作用了，越来越多的言语最先到场闭包，匿名函数等异常典范的函数式编程的特征，从某种程度上来讲，函数式编程正在逐渐“同化”敕令式编程。

JavaScript 作为一种典范的多范式编程言语，这两年跟着React的炽热，函数式编程的观点也最先流行起来，RxJS、cycleJS、lodashJS、underscoreJS等多种开源库都运用了函数式的特征。所以下面引见一些函数式编程的学问和观点。

二、纯函数

假如你还记得一些初中的数学学问的话，函数 f 的观点就是，关于输入 x 发生一个输出 y = f(x)。这便是一种最简朴的纯函数。纯函数的定义是，关于雷同的输入，永久会获得雷同的输出，而且没有任何可视察的副作用，也不依靠外部环境的状况。

下面来举个栗子，比方在Javascript中关于数组的操纵，有些是纯的，有些就不是纯的：

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

// Array.slice是纯函数，由于它没有副作用，关于牢固的输入，输出老是牢固的
// 可以，这很函数式
xs.slice(0,3);
//=> [1,2,3]
xs.slice(0,3);
//=> [1,2,3]


// Array.splice是不纯的，它有副作用，关于牢固的输入，输出不是牢固的
// 这不函数式
xs.splice(0,3);
//=> [1,2,3]
xs.splice(0,3);
//=> [4,5]
xs.splice(0,3);
//=> []

在函数式编程中，我们想要的是 slice 如许的纯函数，而不是 splice这类每次调用后都邑把数据弄得一团乱的函数。

为何函数式编程会排挤不纯的函数呢？下面再看一个例子：

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

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

在不纯的版本中，checkage 这个函数的行动不仅取决于输入的参数 age，还取决于一个外部的变量 min，换句话说，这个函数的行动须要由外部的体系环境决议。关于大型体系来讲，这类关于外部状况的依靠是形成体系庞杂性大大提高的重要缘由。

可以注意到，纯的 checkage 把症结数字 18 硬编码在函数内部，扩展性比较差，我们可以在后面的柯里化中看到怎样用文雅的函数式处置惩罚这类题目。

纯函数不仅可以有用下降体系的庞杂度，另有许多很棒的特征，比方可缓存性：

import _ from 'lodash';

var sin = _.memorize(x => Math.sin(x));
//第一次盘算的时刻会稍慢一点
var a = sin(1);
//第二次有了缓存，速率极快
var b = sin(1);

三、函数的柯里化

函数柯里化（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 add200 = add(200);

add2(2); // =>4
add200(50); // =>250

关于加法这类极为简朴的函数来讲，柯里化并没有什么大用途。

还记得上面谁人checkage的函数吗？我们可以如许柯里化它：

var checkage = min => (age => age > min);
var checkage18 = checkage(18);

checkage18(20);
// =>true

事实上柯里化是一种“预加载”函数的要领，经由过程通报较少的参数，获得一个已记住了这些参数的新函数，某种意义上讲，这是一种对参数的“缓存”，是一种异常高效的编写函数的要领：

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"]

四、函数组合

学会了运用纯函数以及怎样把它柯里化以后，我们会很轻易写出如许的“包菜式”代码：

h(g(f(x)));

虽然这也是函数式的代码，但它依旧存在某种意义上的“不文雅”。为了处置惩罚函数嵌套的题目，我们须要用到“函数组合”：

//两个函数的组合
var compose = function(f, g) {
    return function(x) {
        return f(g(x));
    };
};

//或许
var compose = (f, g) => (x => f(g(x)));

var add1 = x => x + 1;
var mul5 = x => x * 5;

compose(mul5, add1)(2);
// =>15 

我们定义的compose就像双面胶一样，可以把任何两个纯函数结合到一同。固然你也可以扩展出组合三个函数的“三面胶”，以至“四周胶”“N面胶”。

这类天真的组合可以让我们像拼积木一样来组合函数式的代码：

var first = arr => arr[0];
var reverse = arr => arr.reverse();

var last = compose(first, reverse);

last([1,2,3,4,5]);
// =>5

五、Point Free

有了柯里化和函数组合的基础学问，下面引见一下Point Free这类代码作风。

仔细的话你可以会注意到，之前的代码中我们老是喜好把一些对象自带的要领转化成纯函数：

var map = (f, arr) => arr.map(f);
var toUpperCase = word => word.toUpperCase();

这类做法是有缘由的。

Point Free这类形式如今还临时没有中文的翻译，有兴致的话可以看看这里的英文诠释：
https://en.wikipedia.org/wiki…

用中文诠释的话也许就是，不要定名转瞬即逝的中心变量，比方：

//这不Piont free
var f = str => str.toUpperCase().split(' ');

这个函数中，我们运用了 str 作为我们的中心变量，但这个中心变量除了让代码变得长了一点以外是毫无意义的。下面革新一下这段代码：

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

var f = compose(split(' '), toUpperCase);

f("abcd efgh");
// =>["ABCD", "EFGH"]

这类作风可以协助我们削减不必要的定名，让代码坚持简约和通用。固然，为了在一些函数中写出Point Free的作风，在代码的别的处所必定是不那末Point Free的，这个处所须要本身弃取。

六、声明式与敕令式代码

敕令式代码的意义就是，我们经由过程编写一条又一条指令去让盘算机实行一些行动，这个中平常都邑涉及到许多冗杂的细节。

而声明式就要文雅许多了，我们经由过程写表达式的体式格局来声明我们想干什么，而不是经由过程一步一步的指导。

//敕令式
var CEOs = [];
for(var i = 0; i < companies.length; i++){
    CEOs.push(companies[i].CEO)
}

//声明式
var CEOs = companies.map(c => c.CEO);

敕令式的写法要先实例化一个数组，然后再对 companies 数组举行for轮回遍历，手动定名、推断、增添计数器，就好像你开了一辆零件悉数暴露在外的汽车一样，虽然很机器朋克风，但这并非文雅的程序员应当做的。

声明式的写法是一个表达式，怎样举行计数器迭代，返回的数组怎样收集，这些细节都隐蔽了起来。它指明的是做什么，而不是怎么做。除了越发清楚和简约以外，map 函数还可以进一步自力优化，以至用诠释器内置的速率极快的 map 函数，这么一来我们重要的营业代码就不必改动了。

函数式编程的一个显著的优点就是这类声明式的代码，关于无副作用的纯函数，我们完全可以不斟酌函数内部是怎样完成的，专注于编写营业代码。优化代码时，眼光只须要集合在这些稳固牢固的函数内部即可。

相反，不纯的不函数式的代码会发生副作用或许依靠外部体系环境，运用它们的时刻老是要斟酌这些不清洁的副作用。在庞杂的体系中，这关于程序员的心智来讲是极大的累赘。

七、尾声

任何代码都是要有实际用途才有意义，关于JS来讲也是云云。但是实际的编程天下明显不如类型中的函数式天下那末优美，实际运用中的JS是要接触到ajax、DOM操纵，NodeJS环境中读写文件、收集操纵这些关于外部环境强依靠，有显著副作用的“很脏”的事情。

这关于函数式编程来讲也是很大的应战，所以我们也须要更壮大的手艺去处置惩罚这些“脏题目”。我会鄙人一篇文章中引见函数式编程的越发高阶一些的学问，比方Functor、Monad等等观点。