有時,優雅的實作就是一個函式。不是方法,不是類別,不是框架,只是函式。 —— John Carmack,《毀滅戰士》首席程式設計師
函數式程式設計關心的是「如何把問題拆解成一串函式」。函式之間鏈接、嵌套、彼此傳遞,並被當成頭等公民看待。用過 jQuery 或 Node.js 的人其實早就寫過這種風格的程式碼,只是未必意識到。
假設要收集一組值,這些值來自若干個一般物件:
var obj1 = {value: 1}, obj2 = {value: 2}, obj3 = {value: 3};
var values = [];
function accumulate(obj) { values.push(obj.value) }
accumulate(obj1);
accumulate(obj2);
console.log(values); // [1, 2]
能跑,但很脆弱。任何程式碼都能繞過 accumulate() 直接改動 values;而且一旦忘了先給 values 指派空陣列,整段就完全不動了。
把變數移進函式內部似乎能解決:
function accumulate2(obj) {
var values = [];
values.push(obj.value);
return values;
}
console.log(accumulate2(obj1)); // [1]
console.log(accumulate2(obj2)); // [2]
反而更糟——每次呼叫都拿到一個全新的陣列,只裝著當次那一筆。
真正需要的是一个「會記得自己見過什麼」的函式。這正是閉包的用武之地:
var ValueAccumulator = function() {
var values = [];
var accumulate = function(obj) {
if (obj) {
values.push(obj.value);
return values;
} else {
return values;
}
};
return accumulate; // 把函式交出去
};
var accumulator = ValueAccumulator();
accumulator(obj1);
accumulator(obj2);
console.log(accumulator()); // [1, 2]
重点在于 values 宣告在 ValueAccumulator 的作用域裡,而 accumulate 這個內部函式仍然看得到它——即使外層函式早就執行完畢、堆疊框已經退出。這就是閉包:函式可以存取父作用域,哪怕父函式已經結束。
閉包是所有函數式語言必備的特徵,傳統命令式語言多半沒有。它不是語法糖,而是把「狀態」與「行為」綁在一起的一種手段,同時又不必宣告一個類別。
上面那個「回傳函式的函式」就是高階函式的一種形式。高階函式的定義很簡單:以函式為輸入,或以函式為輸出。
命令式程式設計師用迴圈遍歷陣列;函數式程式設計師把函式套到每個元素上,得到新陣列。這兩種思路的差別,比看起來大得多——前者關注「怎麼走」,後者關注「要變成什麼」。
var accumulator2 = ValueAccumulator(); var objects = [obj1, obj2, obj3]; // 這個陣列可以很大 objects.forEach(accumulator2); console.log(accumulator2()); // [1, 2, 3]
在 JavaScript 裡函式是一等公民,與 Scheme、Haskell 相同:數字和物件可以被到處傳遞,函式同樣可以。
純函式的回傳值只取決於傳入參數,不讀取外部變數與全域狀態,也不產生副作用——包含不得改動傳入的參數。數學上的函式就是這個意思:Math.sqrt(4) 永遠回傳 2,不偷看任何隱藏狀態,也不改變世界。
// 非純:依賴 window 的狀態,且自己動手掛上 DOM
var printCenter = function(str) {
var elem = document.createElement("div");
elem.textContent = str;
elem.style.position = 'absolute';
elem.style.top = window.innerHeight / 2 + "px";
elem.style.left = window.innerWidth / 2 + "px";
document.body.appendChild(elem);
};
// 純:座標由參數決定,只負責回傳元素
var printSomewhere = function(str, height, width) {
var elem = document.createElement("div");
elem.textContent = str;
elem.style.position = 'absolute';
elem.style.top = height + "px";
elem.style.left = width + "px";
return elem;
};
非純版本看起來更好用,因為它把「掛上頁面」這件事一起做完了。但純版本回傳元素,反而能與其他函數式技巧自由組合:
var messages = ['Hi', 'Hello', 'Sup', 'Hey', 'Hola'];
messages.map(function(s, i) {
return printSomewhere(s, 100 * i * 10, 100 * i * 10);
}).forEach(function(element) {
document.body.appendChild(element);
});
而且,當函式不依賴狀態與環境,什麼時候計算它就不重要了——這是後面談惰性求值的伏筆。
函式是一等物件帶來的另外一個好處。顧名思義,匿名函式就是沒有名字的函式,它讓你能「就地」定義臨時邏輯。如果一個函式只會用一次,何必替它想一個變數名?
// 標準寫法
function() { return "hello world" };
// 指派給變數
var anon = function(x, y) { return x + y };
// 最常見的用法:當作回呼
setInterval(function() { console.log(new Date().getTime()) }, 1000);
// 反例:這樣寫會立刻執行,只回傳 undefined 給 setInterval
setInterval(console.log(new Date().getTime()), 1000);
與高階函式搭配時,匿名函式能做出很優雅的工廠:
function powersOf(x) {
return function(y) { // 這裡就是匿名函式
return Math.pow(x, y);
};
}
var powerOfTwo = powersOf(2);
console.log(powerOfTwo(1), powerOfTwo(2), powerOfTwo(3)); // 2 4 8
var powerOfThree = powersOf(3);
console.log(powerOfThree(3), powerOfThree(10)); // 9 59049
累加器也能用「立即自我呼叫」的匿名函式改寫:
var values = (function() {
var values = []; // 閉包中的私有狀態
return function(obj) {
if (obj) { values.push(obj.value); return values; }
return values;
}
})();
console.log(values(obj1)); // [1]
console.log(values(obj2)); // [1, 2]
函式後面那對括號讓它立刻執行,因此外層 values 拿到的是「執行結果」,也就是內部那個仍保有狀態的函式。這裡同時用上了高階函式、匿名函式、閉包與純函式風格。
匿名函式並不只是語法糖,它是 lambda 演算的化身。lambda 演算出現得比電腦還早,只定義了三種表達式——變數引用、函式呼叫、匿名函式——卻被證明是圖靈完備的,如今位於所有函數式語言(包含 JavaScript)的核心,因此匿名函式常被稱為 lambda 表達式。
代價是:匿名函式在呼叫堆疊中難以辨識,除錯時只看到一長串 anonymous,請節制使用。
把方法串成一串在 JavaScript 裡很常見,jQuery 就是靠這個招式打天下的,有時也被稱為「建造者模式」。
var arr1 = [1, 2, 3, 4]; var arr2 = arr1.slice().reverse(); var arr3 = arr2.concat([5, 6]); var arr4 = arr3.map(Math.sqrt); // 串成一條 console.log([1, 2, 3, 4].slice().reverse().concat([5, 6]).map(Math.sqrt));
這招只在函式是目標物件的成員時有效。若要自創方法,得掛到 prototype 上:
Array.prototype.zip = function(arr2) {
// ...
};
[1,2,3,4].zip([11,12,13,14]).map(function(n){ return n * 2 });
不過污染原生 prototype 在多人專案裡風險不小,較穩妥的做法是寫成獨立工具函式,或只在受控環境中使用。
遞迴大概是最有名的函數式技巧:函式呼叫自己。它同時具有兩副面孔——既像迴圈般重複執行同一段程式,又是一疊函式呼叫堆疊。
使用遞迴必須有停止條件,也就是所謂的基準情形(base case),否則就是無限遞迴。
var foo = function(n) {
if (n < 0) { // 基準情形
return 'hello';
} else { // 遞迴情形
return foo(n - 1); // 注意這個 return 不能省
}
}
console.log(foo(5));
遞迴與迴圈可以互相轉換,但有些結構用遞迴表達起來自然得多,例如遍歷樹:
var getLeafs = function(node) {
if (node.childNodes.length == 0) {
return node.innerText; // base case
} else {
return node.childNodes.map(getLeafs); // recursive case
}
}
遞迴不只是迴圈的替代品。分而治之(divide and conquer)把問題層層拆小,直到小到可以直接求解。最古老的例子是歐幾里得演算法,用來求最大公因數:
function gcd(a, b) {
if (b == 0) { // 治
return a;
} else { // 分
return gcd(b, a % b);
}
}
console.log(gcd(12, 8)); // 4
console.log(gcd(100, 20)); // 20
排序是更實際的舞臺。JavaScript 原生的 sort 會改動原陣列,行為也不夠可控。用分而治之自己實作合併排序,就能保持不可變性:
var mergeSort = function(arr) {
if (arr.length < 2) {
return arr; // 基準情形:0 或 1 個元素不必排
}
var middle = Math.floor(arr.length / 2);
var left = mergeSort(arr.slice(0, middle)); // 分
var right = mergeSort(arr.slice(middle));
return merge(left, right); // 治:merge 為回傳新陣列的輔助函式
}
實務上,快速排序的程式碼更短、平均效能更好,同樣是分而治之的應用。
惰性求值(又稱非嚴格求值)把計算往後延,直到真的需要結果時才執行。寫成 x = func() 時,x 的值起初並不重要,等到有人取用 x 才呼叫 func()。
這個策略在方法鏈與大陣列上效果顯著,最令人振奮的優點是讓「無限序列」成為可能——因為在被迫求值之前,什麼都不必真的算出來:
// 理想化的偽代碼 var infiniteNums = range(1, Infinity); var tenPrimes = infiniteNums.getPrimeNumbers().first(10);
這為非同步執行、平行計算、資料流組合等場景敞開了門。
遺憾的是 JavaScript 本身不支援惰性求值,多數引擎採用的是「按名呼叫」而非「按需呼叫」。想要這項能力,得靠 Lazy.js、Sloth.js、wu.js 這類函式庫模擬。不可變資料則可以靠程式紀律達成,尾遞迴消除也有 Trampolining 這類技巧可用——只是這些都需要開發者自覺,語言層面並不會替你擋。
函數式程式設計不是一套禁令,而是一組傾向:傾向純函式、傾向把邏輯當值傳遞、傾向用遞迴與轉換取代命令式的手工搬運。JavaScript 具備了實踐這些傾向的全部語法基礎,剩下的取決於你怎麼用它。