JavaScript函數式編程（一）

1、引言

說到函數式編程，你們可能第一印象都是學院派的那些晦澀難懂的代碼，充滿了一大堆抽象的不知所云的符號，彷佛只有大學裏的計算機教授纔會使用這些東西。在曾經的某個時代可能確實如此，可是近年來隨着技術的發展，函數式編程已經在實際生產中發揮巨大的做用了，愈來愈多的語言開始加入閉包，匿名函數等很是典型的函數式編程的特性，從某種程度上來說，函數式編程正在逐步「同化」命令式編程。

JavaScript 做爲一種典型的多範式編程語言，這兩年隨着React的火熱，函數式編程的概念也開始流行起來，RxJS、cycleJS、lodashJS、underscoreJS等多種開源庫都使用了函數式的特性。因此下面介紹一些函數式編程的知識和概念。

2、純函數

若是你還記得一些初中的數學知識的話，函數 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);

3、函數的柯里化

函數柯里化（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"]

4、函數組合

學會了使用純函數以及如何把它柯里化以後，咱們會很容易寫出這樣的「包菜式」代碼：

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

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的，這個地方須要本身取捨。

6、聲明式與命令式代碼

命令式代碼的意思就是，咱們經過編寫一條又一條指令去讓計算機執行一些動做，這其中通常都會涉及到不少繁雜的細節。

而聲明式就要優雅不少了，咱們經過寫表達式的方式來聲明咱們想幹什麼，而不是經過一步一步的指示。

//命令式
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 函數，這麼一來咱們主要的業務代碼就無須改動了。

函數式編程的一個明顯的好處就是這種聲明式的代碼，對於無反作用的純函數，咱們徹底能夠不考慮函數內部是如何實現的，專一於編寫業務代碼。優化代碼時，目光只須要集中在這些穩定堅固的函數內部便可。

相反，不純的不函數式的代碼會產生反作用或者依賴外部系統環境，使用它們的時候老是要考慮這些不乾淨的反作用。在複雜的系統中，這對於程序員的心智來講是極大的負擔。

7、尾聲

任何代碼都是要有實際用處纔有意義，對於JS來講也是如此。然而現實的編程世界顯然不如範例中的函數式世界那麼美好，實際應用中的JS是要接觸到ajax、DOM操做，NodeJS環境中讀寫文件、網絡操做這些對於外部環境強依賴，有明顯反作用的「很髒」的工做。

這對於函數式編程來講也是很大的挑戰，因此咱們也須要更強大的技術去解決這些「髒問題」。我會在下一篇文章中介紹函數式編程的更加高階一些的知識，例如Functor、Monad等等概念。