這周心血來潮，翻看了現在比較流行的幾個 JS 腳本框架的底層代碼，雖然是走馬觀花，但也受益良多，感嘆先人們的偉大……

感嘆是為了緩解嚴肅的氣氛并引出今天要講的話題，”javascript 面向對象編程”，接下來，我們圍繞面向對象的幾大關鍵字：封裝，繼承，多態，展開。

封裝：javascript 中創建對象的模式中，個人認為通過閉包才算的上是真正意義上的封裝，所以首先我們先來簡單介紹一下閉包，看下面這個例子：

<script type="text/javascript">// <![CDATA[
function myInfo(){
var name ="老魚",age =27;
var myInfo = "my name is" + name + "i am" + age +"years old";
function showInfo(){
alert(myInfo);
}
return showInfo;
}
var oldFish = myInfo();
oldFish();
// ]]></script>

是不是很眼熟呢？沒錯了，這其實就是一個簡單的閉包應用了。簡單解釋一下：上面的函數 myInfo 中定義的變量，在它的內嵌函數 showInfo 中是可訪問的（這個很好理解），但是當我們把這個內嵌函數的返回引用賦值給一個變量 oldFish，這個時候函數 showInfo 是在 myInfo 函數體外被調用，但是同樣可以訪問到定義在函數體內的變量。oh yeah!

總結一下閉包的原理吧：函數是運行在定義他們的作用域中而不是調用他們的作用域中。

其實返回一個內嵌函數也是創建閉包最常用的一種方法！

如果覺得上面的解釋太抽象的話，那么我們一起重塑上面的函數，看看這樣是否層次鮮明一些：

<script type="text/javascript">// <![CDATA[
var ioldFish = function(name,age){
var name = name,age = age;
var myInfo = "my name is" + name + "i am" + age +"years old";
return{
showInfo:function(){
alert(myInfo);
}
}
}
ioldFish("老魚",27).showInfo();
// ]]></script>

上例中的編碼風格是 ext yui 中比較常見的，公私分明，一目了然。通過閉包，我們可以很方便的把一些不希望被外部直接訪問到的東西隱藏起來，你要訪問函數內定義的變量，只能通過特定的方 法才可以訪問的到，直接從外部訪問是訪問不到的，寫的挺累，饒了一圈終于轉回來了，封裝嘛，不就是把不希望被別人看到的東西隱藏起來嘛！哈哈……

上例如果轉換成 JQ 的風格的話，應該如下例所寫， 這樣的封裝模式屬于門戶大開型模式，里面定義的變量是可以被外部訪問到的（下面的例子如果你先實例化一個對象，然后在函數外部訪問對象的 name 或者 age 屬性都是可以讀取到的）當然這種模式下我們可以設置一些”潛規則”，讓團隊開發成員明白哪些變量是私用的，通常我們人為的在私有變量和方法前加下劃 線”_”，標識警戒訊號！從而實現”封裝”！

<script type="text/javascript">// <![CDATA[
var ioldFish = function(name,age){
return ioldFish.func.init(name,age);
};
ioldFish.func = ioldFish.prototype ={
init:function(name,age){
this.name = name;
this.age = age;
return this;
},
showInfo:function(){
var info = "my name is" + this.name +"i am " +this.age+"years old";
alert(info);
}
};
ioldFish.func.init.prototype = ioldFish.func;
ioldFish(" 老 魚",27).showInfo();
//var oldFish = new ioldFish("老魚",27);
//alert(oldFish.name);
// ]]></script>

可能有人會問，哪種模式好呢？這個怎么說呢？兩種方式都有優缺點，結合著用唄！總之一個原則，一定一定不能直接被外部對象訪問的東西，就用閉包封裝吧。”一定一定”四個字很深奧，不斷實踐中才能體會真諦！

繼承：提到這個的時候，要順便再補充一句：閉包封裝中的一個缺點，不利于子類的派生，所以閉包有風險，封裝需謹慎！直觀起見，下面例子中創建對象的方式，采用”門戶大開型”模式。

在 javascript 中，繼承一般分為三種方式：”類式繼承”，”原型繼承”，”摻元類”。

下面簡單的介紹一下三類繼承方式的原理：

A.類式繼承：這個是現在主流框架中常用的繼承方式，看下例：

<script type="text/javascript">// <![CDATA[
var Name = function(name){
this.name = name;
};
Name.prototype.getName = function(){
alert(this.name);
};
var Fish = function(name,age){
Name.call(this,name);
this.age = age;
};
Fish.prototype = new Name();
Fish.prototype.constructor = Fish;
Fish.prototype.showInfo = function(){
alert(this.age);
}
var ioldFish = new Fish("老魚",27);
ioldFish.getName();
// ]]></script>

上述子類 Fish 中并沒定義 getName 方法，但是子類 Fish 的實例對象 ioldFish 依然調用到了該方法，這是因為子類 Fish 繼承了超類 Name 中定義的 getName 方法。解釋一下，這里子類 Fish 的 prototype 指到了超類的一個實例，在子類 Fish 中雖然沒有申明 getName 方法，但是根據原型鏈原理，會向 prototype 指向的上一級對象中去查找是否有該方法，如果沒找到該方法，會一直搜索到最初的原型對象。這其實也就是繼承的原理了。這里特別說明一下，Fish.prototype.constructor = Fish; 這句，由于默認子類的 prototype 應該是指向本身的，但是之前把 prototype 指向到了超類的實例對象，所以在這里要把它設置回來。當然這里可以把相關代碼通過一個函數來組織起來，起到偽裝 extend 的作用，這里不再闡述，可以關注本人下篇博文……

B.原型繼承：從內存性能上看優于類式繼承。看下例：

<script type="text/javascript">// <![CDATA[
function clone(object){
var F = function(){};
F.prototype = object;
return new F();
};
var Name = {
name:"who's name",
showInfo:function(){
alert(this.name);
}
};
var Fish = clone(Name);
//Fish.name = "老魚";
Fish.showInfo();
// ]]></script>

很明顯，原型繼承核心就是這個 clone 函數，同樣是原型鏈的原理，不同的是它直接克隆超類，這樣的話子類就繼承了超類的所有屬性和方法.特別說一下，這類繼承并不需要創建構造函數，只需要創建一個對象字變量，定義相應的屬性和方法，然后在子類中只需要通過圓點”.”符號來引用屬性和方法就可以了。

C.摻元類：把一些常用通用性比較大的方法統一封裝在一個函數中，然后通過下面這個函數分派給要用到這些方法的類。還可以針對不同的類，選擇性的傳遞需要的方法。

<script type="text/javascript">// <![CDATA[
function agument(receveClass,giveClass){
if(arguments[2]){
var len = arguments.length;
for(i=2;i<len;i++){
receveClass.prototype[arguments[i]] = giveClass.prototype[arguments[i]];
}
}
else{
for(method in giveClass.prototype){
if(!receveClass.prototype[method]){
receveClass.prototype[method] = giveClass.prototype[method];
}
}
}
};
var Name = function(){};
Name.prototype ={
sayLike:function(){
alert("i like oldfish");
},
sayLove:function(){
alert("i love oldfish");
}
}
var Fish = function(){};
var ioldFish = new Fish();
agument(Fish,Name,"sayLove");
ioldFish.sayLove();
ioldFish.sayLike();
// ]]></script>

多態：個人覺得這個比較抽象，很難言傳，所以下面就從重載和覆蓋兩個方面來簡單闡述一下。

重載：上面這個例子中 agument 函數初始帶了兩個參數，但是在后面的調用中，agument(Fish,Name,”sayLove”) 同樣可以帶入任意多個參數，javascript 的重載，是在函數中由用戶自己通過操作 arguments 這個屬性來實現的。

覆蓋：這個很簡單，就是子類中定義的方法如果與從超類中繼承過來的的方法同名，就覆蓋這個方法（這里并不是覆蓋超類中的方法，注意一下），這里就不累贅了！

最后重點著墨說一下 this 和執行上下文，在前面舉的封裝例子中，this 都是表示 this 所在的類的實例化對象本身，但是并不是千篇一律的，打個比方，通過 HTML 屬性定義的事件處理代碼，見如下代碼：

<script type="text/javascript">// <![CDATA[
var Name = function(name) {
this.name = name;
this.getName = function () {
alert(this.name);
}
};
var ioldFish = new Name("老魚"),
btn = document.getElementById('btn');
btn.onclick = ioldFish.getName;
//btn.onclick = function(){ioldFish.getName.call(ioldFish)};
// ]]></script>

上例中點了按鈕以后彈出框里并沒有顯示出實例對象的屬性，這是因為 this 的執行上下文已經改變了，他現在所在的上下文應該是 input 這個 HTML 標簽，但是該標簽又不存在 getName 這個屬性，所以自然無法輸出這個屬性的屬性值了！從這個例子我們不難看出：執行上下文是在執行時才確定的，它隨時可以變。

當然你可以去掉上面我注釋掉的那段代碼，通過 call 改變 this 的執行上下文，從而獲取 getName 方法。apply 方法同樣可以實現改變執行上下文的功能，不過在 prototype 框架中發現了一個更為優美的實現方法 bind。看一下這個方法的實現吧，不得不感嘆先人的偉大……

Function.prototype.bind = function(obj) {
var method = this,
temp = function() {
return method.apply(obj, arguments);
};
}

相信如果能看明白的話，您已經可以靠這些知識點，去寫一個簡單的腳本框架了，多多實踐，相信不久的將來就能高手進級了！如果沒看明白，也不用著急，面向對象本來就有些抽象，多練習練習，應該 OK 的了，加油……

本文轉自鋼鋼博客園博客，原文鏈接：http://www.cnblogs.com/xugang/archive/2010/06/18/1759996.html，如需轉載請自行聯系原作者

總結

以上是生活随笔為你收集整理的浅谈JavaScript 面向对象编程[转]的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。