雖然 JavaScript 天生一副隨隨便便的樣子,但隨著瀏覽器能承擔的工作越來越多,這門語言也越來越需要「正襟危坐」。在複雜邏輯下,JS 需要被模塊化,模塊需要被良好封裝,只暴露給外界調用的接口。而閉包,正是實現封裝的關鍵,也是許多初學者難以理解的要點。
我們試圖在頁面上維護一個計數器對象 ticker,它維護一個數值 n。隨著使用者操作,我們可以增加計數(n 加 1),但不能減少 n 或直接改變它,同時還要能隨時查詢這個數值。
一種最直觀的寫法是:
var ticker = {
n:0,
tick:function(){
this.n++;
},
};
這種方式書寫自然、確實有效——需要計數時呼叫 ticker.tick(),需要查詢時讀取 ticker.n。但缺點也很明顯:使用者被允許自由改變 n,比如調用 ticker.n-- 或 ticker.n=-1。我們並沒有對 ticker 進行封裝,n 和 tick() 的可訪問性與 ticker 一樣,都是全局性的。
值得注意,tick() 中訪問 this.n 並非因為 n 是 ticker 的成員,而是因為調用 tick() 的是 ticker。如果寫成:
var func = ticker.tick;
func();
此時調用 tick() 的其實是 window,函數會試圖訪問 window.n 而出錯。因此這種「門戶大開」型方式,往往只用來組織 JSON 風格的資料,而非程序邏輯。
因為 JavaScript 中只有函數具有作用域,從函數體外無法訪問函數內部的變量。所以我們把 ticker 改寫為函數:
function ticker(config){
var n = config.nStart;
function tick(){
n += config.step;
}
}
console.log(ticker.n); // ->undefined
從 tick() 到 ticker() 再到全局,這就是 JavaScript 的「作用域鏈」。但問題來了——怎麼調用 tick()?有兩種解法:一是把方法作為返回值,二是設定外層作用域的變量:
var getN;
function ticker(config){
var n = config.nStart;
getN = function(){
return n;
};
return function(){
n += config.step;
};
}
var tick = ticker({nStart:100,step:2});
tick();
console.log(getN()); // ->102
此時變量 n 就處在「閉包」之中:在 ticker() 外部無法直接訪問它,卻能透過兩個方法觀察或操縱它。我對閉包的理解是:用以保證 n 這種「處在函數作用域內、函數執行結束後仍需維持、可能被其他方式訪問」的變量不被銷毀的機制。
若需要維持兩個同功能對象 ticker1 和 ticker2,就要用到 new 運算符。通過 new 調用一個函數會創建新對象並用它調用函數:
function TICKER(config){
var n = config.nStart;
this.getN = function(){
return n;
};
this.tick = function(){
n += config.step;
}
}
var ticker1 = new TICKER({nStart:100,step:2});
ticker1.tick();
console.log(ticker1.getN()); // ->102
var ticker2 = new TICKER({nStart:20,step:3});
ticker2.tick();
ticker2.tick();
console.log(ticker2.getN()); // ->26
習慣上構造函數採用大寫。TICKER() 仍是個函數,閉包依舊有效,我們無法訪問 ticker1.n。
但上面這個 TICKER() 仍有缺陷:每 new 一次都會生成新的 tick() 函數並佔用新的記憶體空間。我們期望 ticker1.tick 和 ticker2.tick 指向同一個函數對象——這就需要引入「原型」。
JavaScript 中,除 Object 外的對象都有 prototype 屬性,指向另一個對象,並形成原型鏈,最終指向 Object。在某對象上找不到指定方法時,就沿原型鏈向上查找。函數也是對象,因此也有原型對象。通過構造函數構造出的新對象,其原型指向構造函數的原型對象。
你可能會想這樣做:
function TICKER(config){
var n = config.nStart;
}
TICKER.prototype.getN = function{
// attention : invalid implementation
return n;
};
但這是無效的!因為原型對象的方法無法訪問閉包中的內容(變量 n)。正確的做法是:對象保留一些簡潔的、依賴於實例的「私有」方法來訪問閉包,再把複雜的邏輯定義在原型上作為「公有」方法:
function TICKER(config){
var n = config.nStart;
this.getN = function(){
return n;
};
this.tick = function(){
n += config.step;
};
}
TICKER.prototype.tickTimes = function(n){
while(n>0){
this.tick();
n--;
}
};
var ticker1 = new TICKER({nStart:100,step:2});
ticker1.tick();
console.log(ticker1.getN()); // ->102
var ticker2 = new TICKER({nStart:20,step:3});
ticker2.tickTimes(2);
console.log(ticker2.getN()); // ->26
這樣 TICKER 就很好了:它封裝了 n,外部無法直接改變;而複雜的 tickTimes() 定義在原型上,透過調用實例的小函數來操作資料。
實際上,當我們在原型上定義函數時,就已經用到了繼承!JavaScript 並不支持類,瀏覽器只管當前有哪些對象,而不去管它們是什麼 class。在我們的例子中,TICKER() 是個函數對象,正因當前有 ticker1 和 ticker2 兩個對象是通過 new 調用它而來的,TICKER() 便充當了構造函數的作用,而 TICKER.prototype 則充當了「類」的角色。
總結我的建議:將對數據的操作解耦為盡可能小的單元函數,在構造函數中定義為依賴實例的(「私有」)方法;而將複雜的邏輯實現在原型上(「公有」)。如此便能兼得封裝性與效能。
作者:一葉齋主人 出處:www.cnblogs.com/yiyezhai