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

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

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