JavaScript函數語言程式設計（一）

一、引言

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

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

二、純函式

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

import _ from 'lodash';
var sin = _.memorize(x => Math.sin(x));

//第一次計算的時候會稍慢一點
var a = sin(1);

//第二次有了快取，速度極快
var b = sin(1);

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

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

四、函式組合

學會了使用純函式以及如何把它柯里化之後，我們會很容易寫出這樣的“包菜式”程式碼：

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

五、Point Free

有了柯里化和函式組合的基礎知識，下面介紹一下Point Free這種程式碼風格。

細心的話你可能會注意到，之前的程式碼中我們總是喜歡把一些物件自帶的方法轉化成純函式：

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

var toUpperCase = word => word.toUpperCase();

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

var toUpperCase = word => word.toUpperCase();
var split = x => (str => str.split(x));

var f = compose(split(' '), toUpperCase);

f("abcd efgh");
// =>["ABCD", "EFGH"]

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

//宣告式
var CEOs = companies.map(c => c.CEO);