接著看函數——這個帶著魔幻色彩、同時是物件的東西。
在一般程式語言中,要把函數當值使用,需要函數指標或代理之類的機制;但在 ECMAScript 中,函數就是一種物件,具備一般物件的所有特徵。除了可以有自己的屬性與方法,函數還能作為引用型別的值使用:可以作為物件屬性的值,也可以作為另一個函數的參數或回傳值——非同步處理中的回呼函數就是最典型的例子。
var name = 'linjisong';
var person = {name: 'oulinhai'};
function getName(){
return this.name;
}
function sum(){
var total = 0,
l = arguments.length;
for(; l; l--)
{
total += arguments[l-1];
}
return total;
}
// 定義呼叫函數的函數,使用函數作為形式參數
function callFn(fn, arguments, scope){
arguments = arguments || [];
scope = scope || window;
return fn.apply(scope, arguments);
}
// 呼叫 callFn,使用函數作為實際參數
console.info(callFn(getName)); // linjisong
console.info(callFn(getName, '', person)); // oulinhai
console.info(callFn(sum, [1,2,3,4])); // 10
再看一個「函數作為回傳值」的典型例子:
function createComparisonFunction(propertyName) {
return function(object1, object2){
var value1 = object1[propertyName];
var value2 = object2[propertyName];
if (value1 < value2){
return -1;
} else if (value1 > value2){
return 1;
} else {
return 0;
}
};
}
var data = [{name: "Zachary", age: 28}, {name: "Nicholas", age: 29}];
data.sort(createComparisonFunction("name"));
console.info(data[0].name); // Nicholas
data.sort(createComparisonFunction("age"));
console.info(data[0].name); // Zachary
閉包是指有權存取另一個函數作用域中變數的函數。一句常被引用的說法是:物件是帶函數的資料,而閉包是帶資料的函數。
先看「帶的是什麼資料」。回顧上面的例子:回傳的是一個匿名函數,而隨著它被回傳,外層的 createComparisonFunction() 就執行完畢了。依照前面的結論,外層函數的執行環境會被彈出堆疊並銷毀——但接下來的排序中,回傳的匿名函數依然能存取 createComparisonFunction() 作用域中的 propertyName。這說明:雖然執行環境已被銷毀,對應的活動物件並沒有被銷毀,而是作為匿名函數作用域鏈中的一環被保留下來了。
換句話說,回傳的匿名函數所構成的閉包,帶有的資料就是「外層函數對應的活動物件」。由於活動物件的屬性(即外層函數中定義的變數、函數與形式參數)會隨外層程式碼執行而變化,因此最終閉包帶有的是外層函數執行完成後的最終狀態。
這段描述有點抽象,看個例子會更清楚:
function createFunctions(){
var result = new Array();
for (var i = 0; i < 10; i++){
result[i] = function(){
return i;
};
}
return result;
}
var funcs = createFunctions();
for (var i = 0, l = funcs.length; i < l; i++){
console.info(funcs[i]());// 每一個函數都輸出 10
}
原因就在上面那句話:閉包帶有的是活動物件的最終狀態,而 createFunctions() 執行完畢後,屬性 i 已經變成 10,所以每個回傳函數都輸出 10。解法是用匿名函數的作用域來保存狀態:
function createFunctions(){
var result = new Array();
for (var i = 0; i < 10; i++){
result[i] = (function(num){
return function(){
return num;
};
})(i);
}
return result;
}
把每個狀態用一個立即呼叫的匿名函數保存(存在該匿名函數的活動物件中),最終回傳的函數被呼叫時,就能透過閉包帶有的資料正確存取,輸出變成 0,1,...9。
當然,這樣做建立了 10 個閉包,效能上會有影響,因此不建議濫用。另外,由於閉包會把其他執行環境的活動物件掛在自己的作用域鏈上,這也可能造成記憶體洩漏。儘管有效能與記憶體的隱患,閉包的功能實在太強大,下面就來看看它的幾個應用。
A、先看一個 this 的經典陷阱:
<button id='my-btn' title='Button'>Hello</button>
<script type="text/javascript">
var handler = {
title: 'Event',
handleClick: function(event){
console.info(this.title);
}
};
var btn = document.getElementById('my-btn');
btn.onclick = handler.handleClick;
</script>
點擊「Hello」按鈕時,主控台印出的是 Button,而不是期望的 Event。原因是在點擊時,處理函數內部的 this 指向了按鈕物件本身。用閉包可以解決:
btn.onclick = function(event){
handler.handleClick(event);
// 形成一個閉包,呼叫函數的就是物件 handler,
// 函數內部 this 指向 handler,因此會輸出 Event
}
B、更優雅的做法是 ES5 新增的 bind():
if(!Function.prototype.bind){ // 為了在不支援的瀏覽器上也能運行
Function.prototype.bind = function(scope){
var that = this; // 呼叫 bind() 的函數物件
return function(){
that.apply(scope, arguments);
};
};
}
btn.onclick = handler.handleClick.bind(handler);
這個 bind() 的核心技術同樣是建立閉包,把綁定時的參數保存起來,作為函數實際呼叫時的 this。如果不確定是瀏覽器原生支援還是這段程式碼生效,可以把特性判斷拿掉、順便換個方法名試試。
C、綁定預設參數:上面只用了第一個參數來設定 this。若把第二個參數之後的內容當作預填參數,就能為函數綁定預設值:
if(!Function.prototype.bind){
Function.prototype.bind = function(scope){
var that = this;
var args = Array.prototype.slice.call(arguments, 1); // 從第 2 個參數開始
return function(){
var innerArgs = Array.prototype.slice.apply(arguments);
that.apply(scope, args.concat(innerArgs));
};
};
}
D、柯里化:如果綁定時的所有參數都作為預填參數(第一個也不用來設 this),就稱為函數柯里化:
if(!Function.prototype.curry){
Function.prototype.curry = function(){
var that = this;
var args = Array.prototype.slice.call(arguments); // 預填參數陣列
return function(){
var innerArgs = Array.prototype.slice.apply(arguments); // 實際呼叫時的參數
that.apply(this, args.concat(innerArgs));
};
};
}
還記得用遞迴實作費波那契數列嗎?加上閉包緩存後改寫如下:
var fibonacci = (function(){ // 使用閉包緩存,遞迴
var cache = [];
function f(n){
if(1 == n || 2 == n){
return 1;
}else{
cache[n] = cache[n] || (f(n-1) + f(n-2));
return cache[n];
}
}
return f;
})();
var f2 = function(n){ // 不使用閉包緩存,直接遞迴
if(1 == n || 2 == n){
return 1;
}else{
return f2(n-1) + f2(n-2);
}
};
測試程式碼與其在我機器上的執行結果:
var test = function(n){
var start = new Date().getTime();
console.info(fibonacci(n));
console.info(new Date().getTime() - start);
start = new Date().getTime();
console.info(f2(n));
console.info(new Date().getTime() - start);
};
test(10);// 55, 2, 55, 2
test(20);// 6765, 1, 6765, 7
test(30);// 832040, 2, 832040, 643
可以看到,n 值越大,緩存的優勢越明顯——這是因為未經緩存的版本存在大量重複計算,時間複雜度呈指數成長,而加了緩存後降為線性。作為練習,你可以試著改寫階乘函數。
ECMAScript 有語句塊,卻沒有塊級作用域,但我們可以用閉包來模仿,一般格式為:
(function(){
// 這裡是塊語句
})();
這種模式稱為「立即呼叫的函數表達式」(IIFE),已經非常流行,特別是因為 jQuery 原始碼大量使用它而大規模普及起來。
閉包還有許多有趣的應用,例如模仿私有變數與私有函數、模組模式等,這裡先不討論,等深入理解物件之後再看。
關於函數就先說這些。網上也有很多非常棒的文章,有興趣可以自己搜尋閱讀。這裡推薦《JavaScript 高級程序設計(第3版)》譯者的一篇譯文:《命名函數表達式探秘》。在現代開發中,ES6 的 let 已提供了真正的塊級作用域,箭頭函數也解決了大部分 this 綁定的困擾,但閉包本身仍然是理解 JavaScript 執行機制的核心概念。