JavaScript函数式编程(一)

原文连接

引言

说到函数式编程，你们可能第一印象都是学院派的那些晦涩难懂的代码，充满了一大堆抽象的不知所云的符号，彷佛只有大学里的计算机教授才会使用这些东西。在曾经的某个时代可能确实如此，可是近年来随着技术的发展，函数式编程已经在实际生产中发挥巨大的做用了，愈来愈多的语言开始加入闭包，匿名函数等很是典型的函数式编程的特性，从某种程度上来说，函数式编程正在逐步“同化”命令式编程。

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 函数，这么一来咱们主要的业务代码就无须改动了。

函数式编程的一个明显的好处就是这种声明式的代码，对于无反作用的纯函数，咱们彻底能够不考虑函数内部是如何实现的，专一于编写业务代码。优化代码时，目光只须要集中在这些稳定坚固的函数内部便可。

相反，不纯的不函数式的代码会产生反作用或者依赖外部系统环境，使用它们的时候老是要考虑这些不干净的反作用。在复杂的系统中，这对于程序员的心智来讲是极大的负担。