DIV CSS 佈局教程網

深入 JavaScript 函數式程式設計:閉包、純函式、遞迴與惰性求值
編輯:關於JavaScript     
 有時,優雅的實作就是一個函式。不是方法,不是類別,不是框架,只是函式。
 —— 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 具備了實踐這些傾向的全部語法基礎,剩下的取決於你怎麼用它。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved