DIV CSS 佈局教程網

JavaScript 原型 prototype 學習指南:從概念到創建對象的模式
編輯:JavaScript基礎知識     

原型是什麼

Function 類型有一個屬性叫 prototype,直譯過來就是「原型」。它是一個指針,指向一個對象;這個對象裡的屬性和方法,會被該函數生成的所有實例共享。

function Person(){ ... }
Person.prototype = {
  country : 'china',
  sayName : function(){ ... }
}

也就是說:

person1 = new Person();
person2 = new Person();

person1 與 person2 都擁有共同的屬性 country 和方法 sayName,因為它們都通過某個指針(__proto__)指向 Person.prototype 所引用的對象。要注意 __proto__ 並不標準,只有 Chrome、Firefox 等瀏覽器自行實現,實際開發中不該使用,它只是理解 prototype 的輔助。

創建對象的幾種模式

1. 工廠模式

用函數封裝以特定接口創建對象的細節,把重複工作交給函數。

function createPerson(name, age, job){
  var o = new Object();
  o.name = name;
  o.age = age;
  o.job = job;
  o.sayName = function(){
    alert(this.name);
  };
  return o;
}
var person1 = createPerson("jiangshui","22","engineer");

工廠模式解決了多個相似對象重複創建的問題,但沒有解決對象識別問題——它只是造了個對象出來,無法區分這個對象究竟基於哪個模板。

2. 構造函數模式

自定義構造函數,在其中定義對象的屬性和方法。

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = function(){
    alert(this.name);
  };
};
var person1 = new Person(...);

與工廠模式的區別在於三點:沒有顯式創建對象、直接把屬性和方法賦給 this、沒有 return 語句。

Person 是 Function 類型的對象,new 之後會產生一個新對象;由於函數中把參數賦值給了 this 指針,傳入的內容就成了新對象的屬性或方法。約定俗成,構造函數首字母大寫。執行過程分四步:

  • 創建一個新對象
  • 將構造函數作用域賦值給新對象
  • 執行構造函數中的代碼
  • 返回新對象

這樣生成的實例默認包含一個 constructor 屬性指向構造函數:

alert(person1.constructor == Person);

因此構造函數模式具備類型標識能力。另外,構造函數本質上就是普通函數,不用 new 直接調用也完全可以,例如執行 Person.sayName() 會彈出 window.name,因為此時函數在 window 作用域下執行,this 指向 window。

它的缺陷是:方法在每個實例上都重新創建了一遍,導致不同實例上的同名函數並不相等。

person1.sayName == person2.sayName; //false

屬性各自獨立是必需的,那正是一個對象有別於另一個對象的地方;但方法邏輯往往完全一致,反覆複製顯然浪費。把函數放到外面再用指針指向它是一種補救:

function Person(name, age){
  this.name = name;
  this.age = age;
  this.sayName = sayName;
}
function sayName(){
  alert(this.name);
}

代價是這個函數變成了全局函數,與 Person 的關聯很弱,封裝性蕩然無存。於是該原型模式出場了。

3. 原型模式

每個函數都有一個 prototype 屬性指向原型對象,函數生成的實例通過 __proto__ 指向該原型。由此可得:prototype 上的屬性和方法是所有實例共享的。

function Person(){ .... }
Person.prototype.name = "jiangshui";
Person.prototype.sayName = function(){ alert(this.name); };
var person1 = new Person();
person1.sayName(); //jiangshui

或者整體覆蓋:

Person.prototype = {
  constructor : Person,
  name : "jiangshui",
  sayName : function(){ alert(this.name); }
};

第二種寫法覆蓋了整个 prototype,所以要手動把 constructor 指回構造函數,否則它會指向 Object。

梳理一下彼此關係:

  • Person.prototype:原型對象,可定義屬性或方法,被所有實例共用。
  • Person.prototype.constructor == Person:原型對象默認有個 constructor 指回所屬構造函數(覆蓋寫法會丟失它,需要重新指定)。
  • person1 = new Person():構造函數生成實例,實例同時包含構造函數內容與原型對象內容。
  • person1.__proto__:指向創建該實例的原型對象(不規範,不要用)。

用 isPrototypeOf() 可以確認對象之間的關係:

Person.prototype.isPrototypeOf(person1);

讀取屬性時的查找規則是:從當前對象開始,沒有則沿指針搜索原型對象,而不會去搜索構造函數。實例可以訪問但不能重寫原型上的值——若實例中設定了同名屬性,查找就在實例這裡結束,達到覆蓋效果。即使把這個屬性設為 null,也只表示實例上存在該屬性,並不會解除覆蓋。要恢復訪問原型,得用 delete 徹底刪除實例屬性。

原型是動態的:對原型對象的任何修改都能立刻反映到實例上,因為實例與原型之間是鬆散鏈接,每次訪問都會重新查詢。

基於這一點,我們也能給原生對象擴充方法:

String.prototype.startsWith = function(text){
  return this.indexOf(text) == 0;
};
var msg = "Hello World";
msg.startsWith("Hello");

執行之後,所有字符串變量都獲得了這個方法。但並不推薦這麼做——擴充過多會讓代碼難以維護。更稳妥的做法是繼承原生引用類型,再在自定義類型上擴展。

原型模式的問題在於:原型上的所有屬性和方法被全部實例共享,這對函數非常合適,但對引用類型的屬性就會出麻煩:

function Person(){}
Person.prototype = {
  constructor : Person,
  friends : ["greg","jack"]
};
var person1 = new Person();
var person2 = new Person();
person1.friends.push("tom");
console.log(person2.friends);

person2 的 friends 裡竟然多了一個 tom。給 person1 加好友卻影響到了 person2,這顯然不是我們想要的。

4. 組合使用構造函數模式與原型模式

這是最常用的方案:構造函數定義實例屬性,通過參數實現自定義;原型定義方法或需要共享的屬性。既保留自定義能力,又實現共用。

function Person(name, age, job){
  this.name = name;
  this.age = age;
  this.job = job;
  this.friends = ["greg","jack"];
}
Person.prototype = {
  constructor : Person,
  sayName : function(){
    alert(this.name);
  }
};
var jiangshui = new Person("jiangshui","22","engineer");

這些知識的實際用處

這種開發方式主要服務於模塊化與組件化。以常用的彈窗為例:你可以每次複製粘貼彈窗代碼再改改,也可以把彈窗能力抽象封裝成一個組件,之後只需傳參生成實例即可調用。項目越大,這種組織方式的收益越明顯。

原型對象與原型鏈

JavaScript 中萬物皆對象,但對象大致可分兩類:普通對象(Object)和函數對象(Function)。一般說來,通過 new Function 產生的對象是函數對象,其餘都是普通對象。

function f1(){ /* todo */ }
var f2 = function(){ /* todo */ };
var f3 = new Function('x','console.log(x)');
var o1 = {};
var o2 = new Object();
var o3 = new f1();
console.log( typeof f1,  //function
            typeof f2,  //function
            typeof f3,  //function
            typeof o1,  //object
            typeof o2,  //object
            typeof o3   //object
);

f1 是函數聲明,最常見的定義方式;f2 是把匿名函數賦值給變量,屬於函數表達式;f3 不常見,但也確實是一個函數對象。Function 是 JS 自帶的對象,f1、f2 在創建時由 JS 自動以 new Function() 的方式構建,因此這三個都是函數對象。

創建對象的方式有兩種:對象字面量和 new 表達式,o1 與 o2 恰好對應。重點看 o3——若按 Java、C# 的思路,會覺得 o3 是 f1 的實例對象、和 f1 同類型,其實不然。判斷很簡單:o3 不是通過 new Function 產生的,既然不是函數對象,那就是普通對象。

接著看原型與原型鏈。每當創建一個函數對象 f1,它都會內置一些屬性,其中包括 prototype 和 __proto__。prototype 即原型對象,記錄著 f1 的一些屬性和方法。

注意 prototype 對 f1 自身是不可見的,f1 不會查找其中的屬性和方法:

function f(){}
f.prototype.foo = "abc";
console.log(f.foo); //undefined

那 prototype 有什麼用?主要作用就是繼承——原型中定義的屬性和方法是留給「後代」用的,子類完全可以訪問。

這時 __proto__ 登場了。它藏得很深,平時幾乎看不見,但在普通對象和函數對象中都存在,作用是保存父類的 prototype 對象。JS 在用 new 表達式創建對象時,通常會把父類的 prototype 賦值給新對象的 __proto__,一代代傳承下去。

function f(){}
f.prototype.foo = "abc";
var obj = new f();
console.log(obj.foo); //abc

obj 的 __proto__ 保存的是 f 的 prototype。那 f.prototype 的 __proto__ 裡又是什麼?

如圖所示,f.prototype 的 __proto__ 保存的是 Object.prototype;Object.prototype 也有 __proto__,其值為 null,代表原型鏈到此終結。

有了這條原型鏈,執行 obj.foo 時,obj 會先查找自身(但不會查找自己的 prototype),找不到就沿著原型鏈依次向上,最終在 f.prototype 上命中並執行。

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