DIV CSS 佈局教程網

JavaScript 模塊化透解:封裝(閉包)與繼承(原型)
編輯:關於JavaScript     

雖然 JavaScript 天生一副隨隨便便的樣子,但隨著瀏覽器能承擔的工作越來越多,這門語言也越來越需要「正襟危坐」。在複雜邏輯下,JS 需要被模塊化,模塊需要被良好封裝,只暴露給外界調用的接口。而閉包,正是實現封裝的關鍵,也是許多初學者難以理解的要點。

一個計數器的需求

我們試圖在頁面上維護一個計數器對象 ticker,它維護一個數值 n。隨著使用者操作,我們可以增加計數(n 加 1),但不能減少 n 或直接改變它,同時還要能隨時查詢這個數值。

門戶大開的 JSON 風格

一種最直觀的寫法是:

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 這種「處在函數作用域內、函數執行結束後仍需維持、可能被其他方式訪問」的變量不被銷毀的機制。

new 運算符與構造函數

若需要維持兩個同功能對象 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。

原型 prototype 與繼承

但上面這個 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

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