面向?qū)ο?/h2>

一種面向?qū)ο笳Z言需要向開發(fā)者提供四種基本能力：

• 封裝 - 把相關(guān)的信息（無論數(shù)據(jù)或方法）存儲在對象中的能力
• 聚集 - 把一個對象存儲在另一個對象內(nèi)的能力
• 繼承 - 由另一個類（或多個類）得來類的屬性和方法的能力
• 多態(tài) - 編寫能以多種方法運行的函數(shù)或方法的能力
  ECMAScript 支持這些要求，因此可被是看做面向?qū)ο蟮摹?br> <br />

對象應(yīng)用

聲明和實例化

對象的創(chuàng)建方式是用關(guān)鍵字 new 后面跟上實例化的類的名字：

var oObject = new Object();
var oStringObject = new String();

<br />

對象引用

在前面的章節(jié)中，我們介紹了引用類型的概念。在ECMAScript中，不能訪問對象的物理表示，只能訪問對象的引用。每次創(chuàng)建對象，存儲在變量中的都是該對象的引用，而不是對象本身。
<br />

對象廢除

ECMAScript 擁有無用存儲單元收集程序（garbage collection routine），意味著不必專門銷毀對象來釋放內(nèi)存。當(dāng)再沒有對對象的引用時，稱該對象被廢除（dereference）了。
。每當(dāng)函數(shù)執(zhí)行完它的代碼，無用存儲單元收集程序都會運行，釋放所有的局部變量，還有在一些其他不可預(yù)知的情況下，無用存儲單元收集程序也會運行。
把對象的所有引用都設(shè)置為 null，可以強制性地廢除對象。例如：

var oObject = new Object;
// do something with the object here
oObject = null;

每用完一個對象后，就將其廢除，來釋放內(nèi)存，這是個好習(xí)慣。
注意：廢除對象的所有引用時要當(dāng)心。如果一個對象有兩個或更多引用，則要正確廢除該對象，必須將其所有引用都設(shè)置為 null。
<br />

早綁定和晚綁定

所謂綁定（binding），即把對象的接口與對象實例結(jié)合在一起的方法。
早綁定（early binding）是指在實例化對象之前定義它的屬性和方法，ECMAScript 不是強類型語言，所以不支持早綁定。
晚綁定（late binding）指的是編譯器或解釋程序在運行前，不知道對象的類型。使用晚綁定，無需檢查對象的類型，只需檢查對象是否支持屬性和方法即可。ECMAScript 中的所有變量都采用晚綁定方法。這樣就允許執(zhí)行大量的對象操作，而無任何懲罰。
<br />

對象類型

一般來說，可以創(chuàng)建并使用的對象有三種：本地對象、內(nèi)置對象和宿主對象。

本地對象(Boolean, Number, String...)

ECMA-262 把本地對象（native object）定義為“獨立于宿主環(huán)境的 ECMAScript 實現(xiàn)提供的對象”。簡單來說，本地對象就是 ECMA-262 定義的類（引用類型）。它們包括：

• Object
• Function
• Array
• String
• Boolean
• Number
• Date
• RegExp
• Error
• EvalError
• RangeError
• ReferenceError
• SyntaxError
• TypeError
• URIError
  <br />

內(nèi)置對象(Global & Math)

ECMA-262把內(nèi)置對象（built-in object）定義為“由ECMAScript實現(xiàn)提供的、獨立于宿主環(huán)境的所有對象，在ECMAScript程序開始執(zhí)行時出現(xiàn)”。這意味著開發(fā)者不必明確實例化內(nèi)置對象，它已被實例化了。ECMA-262 只定義了兩個內(nèi)置對象，即 Global 和 Math （它們也是本地對象，根據(jù)定義，每個內(nèi)置對象都是本地對象）。
<br />

宿主對象(BOM & DOM)

所有非本地對象都是宿主對象（host object），即由 ECMAScript 實現(xiàn)的宿主環(huán)境提供的對象。
所有 BOM 和 DOM 對象都是宿主對象。
<br />

對象作用域

公用、私有和受保護(hù)作用域

在傳統(tǒng)的面向?qū)ο蟪绦蛟O(shè)計中，包含公有、私有、保護(hù)作用域。
ECMAScript 只有公用作用域，ECMAScript 中的所有對象的所有屬性和方法都是公用的。因此，定義自己的類和對象時，必須格外小心。記住，所有屬性和方法默認(rèn)都是公用的！
由于缺少私有作用域，開發(fā)者確定了一個規(guī)約，說明哪些屬性和方法應(yīng)該被看做私有的。這種規(guī)約規(guī)定在屬性前后加下劃線：

obj._color_ = "blue";

注意，下劃線并不改變屬性是公用屬性的事實，它只是告訴其他開發(fā)者，應(yīng)該把該屬性看作私有的。
<br />

靜態(tài)作用域

靜態(tài)作用域定義的屬性和方法任何時候都能從同一位置訪問。在 Java 中，類可具有屬性和方法，無需實例化該類的對象，即可訪問這些屬性和方法，例如 java.net.URLEncoder 類，它的函數(shù) encode() 就是靜態(tài)方法。
ECMAScript 沒有靜態(tài)作用域
嚴(yán)格來說，ECMAScript 并沒有靜態(tài)作用域。不過，它可以給構(gòu)造函數(shù)提供屬性和方法。還記得嗎，構(gòu)造函數(shù)只是函數(shù)。函數(shù)是對象，對象可以有屬性和方法。例如：

function sayHello() 
{
  alert("hello");
}

sayHello.alternate = function()     // 為函數(shù)添加方法
{   
  alert("hi");
}

sayHello();                         // 輸出 "hello"，可理解為構(gòu)造函數(shù)的調(diào)用
sayHello.alternate();               // 輸出 "hi"，類靜態(tài)方法式的調(diào)用

即使如此，alternate() 也是 sayHello() 公用作用域中的方法，而不是靜態(tài)方法。
<br />

關(guān)鍵字this

它用在對象的方法中。關(guān)鍵字 this 總是指向調(diào)用該方法的對象，例如：

function showColor() {
  alert(this.color);
};

var oCar1 = new Object;
oCar1.color = "red";
oCar1.showColor = showColor;

var oCar2 = new Object;
oCar2.color = "blue";
oCar2.showColor = showColor;

oCar1.showColor();              // 輸出 "red"
oCar2.showColor();              // 輸出 "blue"

注意，引用對象的屬性時，必須使用 this 關(guān)鍵字。例如，如果采用下面的代碼，showColor() 方法不能運行：

function showColor() {
  alert(color);
};

如果不用對象或 this 關(guān)鍵字引用變量，ECMAScript 就會把它看作局部變量或全局變量。然后該函數(shù)將查找名為 color 的局部或全局變量，但是不會找到。結(jié)果如何呢？該函數(shù)將在警告中顯示 "null"。
<br >

定義類和對象

原始的方式

var oCar = new Object;
oCar.color = "blue";
oCar.doors = 4;
oCar.mpg = 25;
oCar.showColor = function() {
  alert(this.color);
};

<br />

工廠方式

function createCar(sColor,iDoors,iMpg) {
  var oTempCar = new Object;
  oTempCar.color = sColor;
  oTempCar.doors = iDoors;
  oTempCar.mpg = iMpg;
  oTempCar.showColor = function() { // 函數(shù)對象每次都會重新創(chuàng)建
    alert(this.color);
  };
  return oTempCar;
}

var oCar1 = createCar("red",4,23);
var oCar2 = createCar("blue",3,25);

oCar1.showColor();      //輸出 "red"
oCar2.showColor();      //輸出 "blue"

前面的例子中，每次調(diào)用函數(shù) createCar()，都要創(chuàng)建新函數(shù) showColor()，意味著每個對象都有自己的 showColor() 版本。而事實上，每個對象都共享同一個函數(shù)。
所以改進(jìn)的版本如下：

function showColor() {
  alert(this.color);
}

function createCar(sColor,iDoors,iMpg) {
  var oTempCar = new Object;
  oTempCar.color = sColor;
  oTempCar.doors = iDoors;
  oTempCar.mpg = iMpg;
  oTempCar.showColor = showColor; // 共享函數(shù)對象
  return oTempCar;
}

var oCar1 = createCar("red",4,23);
var oCar2 = createCar("blue",3,25);

oCar1.showColor();      //輸出 "red"
oCar2.showColor();      //輸出 "blue"

在createCar()內(nèi)部，賦予對象一個指向已經(jīng)存在的showColor()函數(shù)的指針。從功能上講，這樣解決了重復(fù)創(chuàng)建函數(shù)對象的問題；但是從語義上講，該函數(shù)不太像是對象的方法。
<br />

構(gòu)造函數(shù)方式

創(chuàng)建構(gòu)造函數(shù)就像創(chuàng)建工廠函數(shù)一樣容易。第一步選擇類名，即構(gòu)造函數(shù)的名字。根據(jù)慣例，這個名字的首字母大寫，以使它與首字母通常是小寫的變量名分開。除了這點不同，構(gòu)造函數(shù)看起來很像工廠函數(shù)。請考慮下面的例子：

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.showColor = function() { // 每次都會創(chuàng)建函數(shù)對象
    alert(this.color);
  };
}

var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);

下面為您解釋上面的代碼與工廠方式的差別。首先在構(gòu)造函數(shù)內(nèi)沒有創(chuàng)建對象，而是使用 this 關(guān)鍵字。使用 new 運算符構(gòu)造函數(shù)時，在執(zhí)行第一行代碼前先創(chuàng)建一個對象，只有用 this 才能訪問該對象。然后可以直接賦予 this 屬性，默認(rèn)情況下是構(gòu)造函數(shù)的返回值（不必明確使用 return 運算符）。
就像工廠函數(shù)，構(gòu)造函數(shù)會重復(fù)生成函數(shù)，為每個對象都創(chuàng)建獨立的函數(shù)版本。不過，與工廠函數(shù)相似，也可以用外部函數(shù)重寫構(gòu)造函數(shù)，同樣地，這么做語義上無任何意義。這正是下面要講的原型方式的優(yōu)勢所在。
<br />

原型方式(prototype)

該方式利用了對象的 prototype 屬性，可以把它看成創(chuàng)建新對象所依賴的原型。
這里，首先用空構(gòu)造函數(shù)來設(shè)置類名。然后所有的屬性和方法都被直接賦予 prototype 屬性。我們重寫了前面的例子，代碼如下：

function Car() {
}

Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.showColor = function() {
  alert(this.color);
};

var oCar1 = new Car();
var oCar2 = new Car();

調(diào)用 new Car() 時，原型的所有屬性都被立即賦予要創(chuàng)建的對象，意味著所有 Car 實例存放的都是指向 showColor() 函數(shù)的指針。從語義上講，所有屬性看起來都屬于一個對象，因此解決了前面兩種方式存在的問題。
原型方式看起來是個不錯的解決方案。遺憾的是，它并不盡如人意。
首先，這個構(gòu)造函數(shù)沒有參數(shù)。
真正的問題出現(xiàn)在屬性指向的是對象，而不是函數(shù)時。函數(shù)共享不會造成問題，但對象共享卻會造成問題。請思考下面的例子：

function Car() {
}

Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.drivers = new Array("Mike","John");
Car.prototype.showColor = function() {
  alert(this.color);
};

var oCar1 = new Car();
var oCar2 = new Car();

oCar1.drivers.push("Bill");

alert(oCar1.drivers);   //輸出 "Mike,John,Bill"
alert(oCar2.drivers);   //輸出 "Mike,John,Bill"

<br />

混合的構(gòu)造函數(shù)/原型方式

由于創(chuàng)建對象時有這么多問題，你一定會想，是否有種合理的創(chuàng)建對象的方法呢？
答案是有，需要聯(lián)合使用構(gòu)造函數(shù)和原型方式。

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.drivers = new Array("Mike","John");  // 避免對象共享
}

Car.prototype.showColor = function() {      // 使用函數(shù)共享
  alert(this.color);
};

var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);

oCar1.drivers.push("Bill");

alert(oCar1.drivers);   // 輸出 "Mike,John,Bill"
alert(oCar2.drivers);   // 輸出 "Mike,John"

<br />

動態(tài)原型方法(_initialized)

對于習(xí)慣使用其他語言的開發(fā)者來說，使用混合的構(gòu)造函數(shù)/原型方式感覺不那么和諧。畢竟，定義類時，大多數(shù)面向?qū)ο笳Z言都對屬性和方法進(jìn)行了視覺上的封裝。
動態(tài)原型方法的基本想法與混合的構(gòu)造函數(shù)/原型方式相同，唯一的區(qū)別是賦予函數(shù)屬性的位置。下面是用動態(tài)原型方法重寫的 Car 類：

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.drivers = new Array("Mike","John");
  
  if (typeof Car._initialized == "undefined") { // 保證函數(shù)屬性只定義一次
    Car.prototype.showColor = function() {
      alert(this.color);
    };
    
    Car._initialized = true;                    // 定義后，"typeof"運算符返回"boolean"
  }
}

直到檢查typeof Car._initialized是否等于"undefined"之前，這個構(gòu)造函數(shù)都未發(fā)生變化。這行代碼是動態(tài)原型方法中最重要的部分。如果這個值未定義，構(gòu)造函數(shù)將用原型方式繼續(xù)定義對象的方法，然后把Car._initialized設(shè)置為true。如果這個值定義了（它的值為true時，typeof的值為boolean），那么就不再創(chuàng)建該方法。
<br />
如前所述，目前使用最廣泛的是混合的構(gòu)造函數(shù)/原型方式。此外，動態(tài)原始方法也很流行，在功能上與構(gòu)造函數(shù)/原型方式等價。可以采用這兩種方式中的任何一種。
<br />

修改對象

prototype 屬性不僅可以定義構(gòu)造函數(shù)的屬性和方法，還可以為本地對象添加屬性和方法。

創(chuàng)建新方法

通過已有的方法創(chuàng)建新方法

Number.prototype.toHexString = function() {
  return this.toString(16);
};

<br />

重命名已有方法

Array.prototype.enqueue = function(vItem) {
  this.push(vItem);
};

Array.prototype.dequeue = function() {
  return this.shift();
};

<br />

添加與已有方法無關(guān)的方法

Array.prototype.indexOf = function (vItem) {
  for (var i=0; i<this.length; i++) {
    if (vItem == this[i]) {
      return i;
    }
  }

  return -1;
}

<br />

為所有本地對象添加新方法

所有本地對象都繼承了 Object 對象，所以對 Object 對象做任何改變，都會反應(yīng)在所有本地對象上。

Object.prototype.showValue = function () {
  alert(this.valueOf());
};

var str = "hello";
var iNum = 25;
str.showValue();        // 輸出 "hello"
iNum.showValue();       // 輸出 "25"

<br />

重定義已有方法

如前面的章節(jié)所述，函數(shù)名只是指向函數(shù)的指針，因此可以輕松地指向其他函數(shù)。

Function.prototype.toString = function() {
  return "Function code hidden";
}

不過，toString()指向的原始函數(shù)怎么了呢？
它將被無用存儲單元回收程序回收，因為它被完全廢棄了。沒有能夠恢復(fù)原始函數(shù)的方法，所以在覆蓋原始方法前，比較安全的做法是存儲它的指針，以便以后的使用。有時你甚至可能在新方法中調(diào)用原始方法：

Function.prototype.originalToString = Function.prototype.toString;

Function.prototype.toString = function() {
  if (this.originalToString().length > 100) {
    return "Function too long to display.";
  } else {
    return this.originalToString();
  }
};

<br />

極晚綁定(Very Late Binding)

在大多數(shù)程序設(shè)計語言中，必須在實例化對象之前定義對象的方法。 ECMAScript允許在對象實例化后再定義它的方法。

var o = new Object();

Object.prototype.sayHi = function () {
  alert("hi");
};

o.sayHi();

注意：不建議使用極晚綁定方法，因為很難對其跟蹤和記錄。不過，還是應(yīng)該了解這種可能。
<br />

更多請參考：W3School