一、引言

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

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

二、純函數(shù)

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

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

var arr = [1,2,3,4,5]; 
 
// Array.slice是純函數(shù)，因為它沒有副作用，對于固定的輸入，輸出總是固定的 
// 可以，這很函數(shù)式 
xs.slice(0,3); 
//=> [1,2,3] 
xs.slice(0,3); 
//=> [1,2,3] 
 
// Array.splice是不純的，它有副作用，對于固定的輸入，輸出不是固定的 
// 這不函數(shù)式 
xs.splice(0,3); 
//=> [1,2,3] 
xs.splice(0,3); 
//=> [4,5] 
xs.splice(0,3); 
//=> [] 
 

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

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

//不純的 
var min = 18; 
var checkage = age => age > min; 
 
//純的，這很函數(shù)式 
var checkage = age => age > 18; 

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

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

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

import _ from 'lodash'; 
var sin = _.memorize(x => Math.sin(x)); 
 
//***次計算的時候會稍慢一點 
var a = sin(1); 
 
//第二次有了緩存，速度極快 
var b = sin(1); 

三、函數(shù)的柯里化

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

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

//比較容易讀懂的ES5寫法 
 
var add = function(x){ 
 
  return function(y){ 
 
    return x + y 
 
  } 
 
} 
 
//ES6寫法，也是比較正統(tǒng)的函數(shù)式寫法 
 
var add = x => (y => x + y); 
 
//試試看 
 
var add2 = add(2); 
 
var add200 = add(200); 
 
add2(2); // =>4 
 
add200(50); // =>250 

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

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

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

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

import { curry } from 'lodash'; 
 
//首先柯里化兩個純函數(shù) 
 
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"] 

 四、函數(shù)組合

學(xué)會了使用純函數(shù)以及如何把它柯里化之后，我們會很容易寫出這樣的“包菜式”代碼：

h(g(f(x))); 

雖然這也是函數(shù)式的代碼，但它依然存在某種意義上的“不優(yōu)雅”。為了解決函數(shù)嵌套的問題，我們需要用到“函數(shù)組合”：

//兩個函數(shù)的組合 
 
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就像雙面膠一樣，可以把任何兩個純函數(shù)結(jié)合到一起。當(dāng)然你也可以擴展出組合三個函數(shù)的“三面膠”，甚至“四面膠”“N面膠”。

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

var first = arr => arr[0]; 
 
var reverse = arr => arr.reverse(); 
 
var last = compose(first, reverse); 
 
last([1,2,3,4,5]); 
 
// =>5 

五、Point Free

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

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

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

 這種做法是有原因的。

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

https://en.wikipedia.org/wiki/Tacit_programming

用中文解釋的話大概就是，不要命名轉(zhuǎn)瞬即逝的中間變量，比如：

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

 這個函數(shù)中，我們使用了 str 作為我們的中間變量，但這個中間變量除了讓代碼變得長了一點以外是毫無意義的。下面改造一下這段代碼：

var toUpperCase = word => word.toUpperCase(); 
 
var split = x => (str => str.split(x)); 
 
var f = compose(split(' '), toUpperCase); 
 
f("abcd efgh"); 
 
// =>["ABCD", "EFGH"] 

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

六、聲明式與命令式代碼

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

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

//命令式 
 
var CEOs = []; 
 
for(var i = 0; i < companies.length; i++){ 
 
  CEOs.push(companies[i].CEO) 
 
} 
 
//聲明式 
 
var CEOs = companies.map(c => c.CEO); 

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

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

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

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

七、尾聲

任何代碼都是要有實際用處才有意義，對于JS來說也是如此。然而現(xiàn)實的編程世界顯然不如范例中的函數(shù)式世界那么美好，實際應(yīng)用中的JS是要接觸到ajax、DOM操作，NodeJS環(huán)境中讀寫文件、網(wǎng)絡(luò)操作這些對于外部環(huán)境強依賴，有明顯副作用的“很臟”的工作。

這對于函數(shù)式編程來說也是很大的挑戰(zhàn)，所以我們也需要更強大的技術(shù)去解決這些“臟問題”。我會在下一篇文章中介紹函數(shù)式編程的更加高階一些的知識，例如Functor、Monad等等概念。