原文链接

弁言

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

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

纯函数

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

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

var arr = [1, 2, 3, 4, 5];
// Array.slice()是纯函数，因为他没有副作用（side_effect）关于牢固的输入老是有牢固的输出，也就是说输入一样，那末输出一定会一样
arr.slice(0, 3);
// => [1, 2, 3]
arr.slice(0, 3);
// => [1, 2, 3]
// 两次的输出效果都一样

// Arrary。splice()就不是纯函数
arr.splice(0, 3)
// => [1, 2, 3]
arr.splice(0, 3)
// => [4, 5]
arr.splice(0, 3)
// => []
// 这里的缘由就是因为slice不会去变动原数组，但是splice会变动原数组
// 假如有什么不明白的请自行检察slice & splice的API

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

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

// 不纯的函数
const min = 18;
const checkage = age => age > min;
// 纯的函数
const checkage = age => age > 18;

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

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

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

import _ from 'lodash';
const sin = _.memrorize(x => Math.sin(x));
// lodash是一个js库
// 第一次盘算会须要一些时刻
const a = sin(1);
// 第二次盘算的时刻会因为有缓存，速率很快
const b = sin(1);

函数的柯里化

函数柯里化（curry）的定义很简朴：通报给函数一部分参数来调用它，让它返回一个函数去处置惩罚剩下的参数。

比方关于加法函数 var add = (x, y) =>　x + y ，我们可以如许举行柯里化：

// 起首是比较轻易读懂的ES5的写法
var add = function(x) {
  return function(y) {
    return x + y;
  }
}

// ES6的写法
const add = x => y => x + y;

// 以后就是柯里化
const add2 = add(2);
const add200 = add(200);

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

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

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

const checkage = min => age => age > min;
const checkage18 = checkage(18);
checkage18(20);
// => true

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

import { curry } from 'lodash';
// 起首柯里化两个函数
// 这里运用的match函数和filter函数都是JS原生的
// 然后应用这两个原生的函数我们创建了属于我们本身的
// match函数和filter函数
const match = curry((reg, str) => str.match(reg));
const filter = cutty((func, arr) => arr.filter(func));

// 推断字符串内里是不是含有空格
const hasSpace = match(/\s+/g);
hasSpace('ffff');
// => null
hasSpace('a b');
// => [' ']
filter(hasSpace, ['asdadads', 'hello world']);
// => ['hello world']

函数组合

为了处置惩罚函数嵌套的题目，我们须要用到“函数组合”：

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

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

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

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

固然须要注重的是函数组合的运转递次是从右至左，右侧的函数在最内里

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

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

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

const last = compose(first, reverse);

last([1,2,3,4,5]);
// =>5
// reverse()函数是一个不纯的函数，会转变原有的数组
const a = ['one', 'two', 'three'];
const reversed = a.reverse();

console.log(a);        // ['three', 'two', 'one']
console.log(reversed); // ['three', 'two', 'one']

Point Free

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

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

const map = (f, arr) => arr.map(f);

const toUpperCase = word => word.toUpperCase();

这类做法是有缘由的。

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

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

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

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

Point Free这类形式如今还临时没有中文的翻译，有兴致的话可以看看这里的英文诠释

声明式与敕令式代码

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

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

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

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

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

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

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

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