摘要：所以下面介紹一些函數(shù)式編程的知識(shí)和概念。函數(shù)式編程的一個(gè)明顯的好處就是這種聲明式的代碼，對(duì)于無副作用的純函數(shù)，我們完全可以不考慮函數(shù)內(nèi)部是如何實(shí)現(xiàn)的，專注于編寫業(yè)務(wù)代碼。

原文鏈接

說到函數(shù)式編程，大家可能第一印象都是學(xué)院派的那些晦澀難懂的代碼，充滿了一大堆抽象的不知所云的符號(hào)，似乎只有大學(xué)里的計(jì)算機(jī)教授才會(huì)使用這些東西。在曾經(jīng)的某個(gè)時(shí)代可能確實(shí)如此，但是近年來隨著技術(shù)的發(fā)展，函數(shù)式編程已經(jīng)在實(shí)際生產(chǎn)中發(fā)揮巨大的作用了，越來越多的語言開始加入閉包，匿名函數(shù)等非常典型的函數(shù)式編程的特性，從某種程度上來講，函數(shù)式編程正在逐步“同化”命令式編程。

JavaScript 作為一種典型的多范式編程語言，這兩年隨著React的火熱，函數(shù)式編程的概念也開始流行起來，RxJS、cycleJS、lodashJS、underscoreJS等多種開源庫都使用了函數(shù)式的特性。所以下面介紹一些函數(shù)式編程的知識(shí)和概念。

如果你還記得一些初中的數(shù)學(xué)知識(shí)的話，函數(shù) f 的概念就是，對(duì)于輸入 x 產(chǎn)生一個(gè)輸出 y = f(x)。這便是一種最簡(jiǎn)單的純函數(shù)。純函數(shù)的定義是，對(duì)于相同的輸入，永遠(yuǎn)會(huì)得到相同的輸出，而且沒有任何可觀察的副作用，也不依賴外部環(huán)境的狀態(tài)。

下面來舉個(gè)栗子，比如在Javascript中對(duì)于數(shù)組的操作，有些是純的，有些就不是純的：

var arr = [1, 2, 3, 4, 5];
// Array.slice()是純函數(shù)，因?yàn)樗麤]有副作用（side_effect）對(duì)于固定的輸入總是有固定的輸出，也就是說輸入一樣，那么輸出一定會(huì)一樣
arr.slice(0, 3);
// => [1, 2, 3]
arr.slice(0, 3);
// => [1, 2, 3]
// 兩次的輸出結(jié)果都一樣

// Arrary。splice()就不是純函數(shù)
arr.splice(0, 3)
// => [1, 2, 3]
arr.splice(0, 3)
// => [4, 5]
arr.splice(0, 3)
// => []
// 這里的原因就是因?yàn)閟lice不會(huì)去更改原數(shù)組，然而splice會(huì)更改原數(shù)組
// 如果有什么不明白的請(qǐng)自行查看slice & splice的API

在函數(shù)式編程中，我們想要的是 slice 這樣的純函數(shù)，而不是 splice這種每次調(diào)用后都會(huì)把數(shù)據(jù)弄得一團(tuán)亂的函數(shù)。

為什么函數(shù)式編程會(huì)排斥不純的函數(shù)呢？下面再看一個(gè)例子：

// 不純的函數(shù)
const min = 18;
const checkage = age => age > min;
// 純的函數(shù)
const checkage = age => age > 18;

在不純的版本中，checkage 這個(gè)函數(shù)的行為不僅取決于輸入的參數(shù) age，還取決于一個(gè)外部的變量 min，換句話說，這個(gè)函數(shù)的行為需要由外部的系統(tǒng)環(huán)境決定。對(duì)于大型系統(tǒng)來說，這種對(duì)于外部狀態(tài)的依賴是造成系統(tǒng)復(fù)雜性大大提高的主要原因。

可以注意到，純的 checkage 把關(guān)鍵數(shù)字 18 硬編碼在函數(shù)內(nèi)部，擴(kuò)展性比較差，我們可以在后面的柯里化中看到如何用優(yōu)雅的函數(shù)式解決這種問題。

純函數(shù)不僅可以有效降低系統(tǒng)的復(fù)雜度，還有很多很棒的特性，比如可緩存性：

import _ from "lodash";
const sin = _.memrorize(x => Math.sin(x));
// lodash是一個(gè)js庫
// 第一次計(jì)算會(huì)需要一些時(shí)間
const a = sin(1);
// 第二次計(jì)算的時(shí)候會(huì)由于有緩存，速度很快
const b = sin(1);

函數(shù)柯里化（curry）的定義很簡(jiǎn)單：傳遞給函數(shù)一部分參數(shù)來調(diào)用它，讓它返回一個(gè)函數(shù)去處理剩下的參數(shù)。

比如對(duì)于加法函數(shù) var add = (x, y) =>　x + y ，我們可以這樣進(jìn)行柯里化：

// 首先是比較容易讀懂的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

對(duì)于加法這種極其簡(jiǎn)單的函數(shù)來說，柯里化并沒有什么大用處。

還記得上面那個(gè) checkage 的函數(shù)嗎？我們可以這樣柯里化它：

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

事實(shí)上柯里化是一種“預(yù)加載”函數(shù)的方法，通過傳遞較少的參數(shù)，得到一個(gè)已經(jīng)記住了這些參數(shù)的新函數(shù)，某種意義上講，這是一種對(duì)參數(shù)的“緩存”，是一種非常高效的編寫函數(shù)的方法：

import { curry } from "lodash";
// 首先柯里化兩個(gè)函數(shù)
// 這里使用的match函數(shù)和filter函數(shù)都是JS原生的
// 然后利用這兩個(gè)原生的函數(shù)我們創(chuàng)建了屬于我們自己的
// match函數(shù)和filter函數(shù)
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"]

為了解決函數(shù)嵌套的問題，我們需要用到“函數(shù)組合”：

//兩個(gè)函數(shù)的組合
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

當(dāng)然需要注意的是函數(shù)組合的運(yùn)行順序是從右至左，右邊的函數(shù)在最里面

我們定義的compose就像雙面膠一樣，可以把任何兩個(gè)純函數(shù)結(jié)合到一起。當(dāng)然你也可以擴(kuò)展出組合三個(gè)函數(shù)的“三面膠”，甚至“四面膠”“N面膠”。

這種靈活的組合可以讓我們像拼積木一樣來組合函數(shù)式的代碼：

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

const last = compose(first, reverse);

last([1,2,3,4,5]);
// =>5
// reverse()函數(shù)是一個(gè)不純的函數(shù)，會(huì)改變?cè)械臄?shù)組
const a = ["one", "two", "three"];
const reversed = a.reverse();

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

有了柯里化和函數(shù)組合的基礎(chǔ)知識(shí)，下面介紹一下Point Free這種代碼風(fēng)格。

細(xì)心的話你可能會(huì)注意到，之前的代碼中我們總是喜歡把一些對(duì)象自帶的方法轉(zhuǎn)化成純函數(shù)：

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

這種風(fēng)格能夠幫助我們減少不必要的命名，讓代碼保持簡(jiǎn)潔和通用。當(dāng)然，為了在一些函數(shù)中寫出Point Free的風(fēng)格，在代碼的其它地方必然是不那么Point Free的，這個(gè)地方需要自己取舍

Point Free這種模式現(xiàn)在還暫且沒有中文的翻譯，有興趣的話可以看看這里的英文解釋

命令式代碼的意思就是，我們通過編寫一條又一條指令去讓計(jì)算機(jī)執(zhí)行一些動(dòng)作，這其中一般都會(huì)涉及到很多繁雜的細(xì)節(jié)。

而聲明式就要優(yōu)雅很多了，我們通過寫表達(dá)式的方式來聲明我們想干什么，而不是通過一步一步的指示。

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

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

命令式的寫法要先實(shí)例化一個(gè)數(shù)組，然后再對(duì) companies 數(shù)組進(jìn)行for循環(huán)遍歷，手動(dòng)命名、判斷、增加計(jì)數(shù)器，就好像你開了一輛零件全部暴露在外的汽車一樣，雖然很機(jī)械朋克風(fēng)，但這并不是優(yōu)雅的程序員應(yīng)該做的。

聲明式的寫法是一個(gè)表達(dá)式，如何進(jìn)行計(jì)數(shù)器迭代，返回的數(shù)組如何收集，這些細(xì)節(jié)都隱藏了起來。它指明的是做什么，而不是怎么做。除了更加清晰和簡(jiǎn)潔之外，map 函數(shù)還可以進(jìn)一步獨(dú)立優(yōu)化，甚至用解釋器內(nèi)置的速度極快的 map 函數(shù)，這么一來我們主要的業(yè)務(wù)代碼就無須改動(dòng)了。

函數(shù)式編程的一個(gè)明顯的好處就是這種聲明式的代碼，對(duì)于無副作用的純函數(shù)，我們完全可以不考慮函數(shù)內(nèi)部是如何實(shí)現(xiàn)的，專注于編寫業(yè)務(wù)代碼。優(yōu)化代碼時(shí)，目光只需要集中在這些穩(wěn)定堅(jiān)固的函數(shù)內(nèi)部即可。

相反，不純的不函數(shù)式的代碼會(huì)產(chǎn)生副作用或者依賴外部系統(tǒng)環(huán)境，使用它們的時(shí)候總是要考慮這些不干凈的副作用。在復(fù)雜的系統(tǒng)中，這對(duì)于程序員的心智來說是極大的負(fù)擔(dān)。