DIV CSS 佈局教程網

JavaScript 的 prototype 機制:從屬性查找到繼承的各種寫法
編輯:JavaScript基礎知識     

JavaScript 的物件有一個特殊的 prototype 內建屬性,它其實就是一個對其他物件的參考。

當我們試圖存取某個物件的屬性時,JS 引擎會觸發一次 GET 操作:先查這個物件自身有沒有該屬性,沒有就沿 prototype 關聯的物件繼續找,以此類推。若一路都沒找到,就繼續往上一層的 prototype 找。這一串串起來的鏈接,就稱為原型鏈。

正因如此,在 JavaScript 中所有物件都能使用 toString()、valueOf(),所有函式都能使用 call()、apply()——普通物件的原型鏈最終指向內建的 Object.prototype,而函式則指向 Function.prototype。

靠 prototype 機制實作「繼承」

JavaScript 實作繼承的底層依據就是 prototype 機制。它與其他靜態類語言不同,並沒有「類」作為物件的抽象模板(ES6 雖然有了 class 關鍵字,但那也只是 prototype 機制的語法糖)。不過我們完全可以寫出模仿類的程式碼,最常見的就是「建構函式模式 + 原型模式」:

function Animal(name, color) {
  this.name  = name;
  this.color = color;
}
Animal.prototype.type = "動物";
Animal.prototype.msg = function () {
  alert("I am " + this.name + ", my color is " + this.color);
};

var cat = new Animal("cat", "black");
console.log(cat.name);                   // cat
console.log(cat.type);                   // 動物
console.log(cat.constructor === Animal); // true

這裡 Animal 這個函式就可以視為一個「類」,裡面定義了 name 與 color。cat 是透過 new 把 Animal 當成建構函式呼叫後產生的新物件,並傳入兩個參數。

用 new 呼叫函式時,實際發生了四件事:

1、建立一個全新的物件;

2、這個新物件會被串上原型鏈接;

3、這個新物件會被綁定到函式呼叫的 this 上;

4、若函式沒有回傳物件,new 表達式會自動回傳這個新物件。

所以 cat 的內部原型全等同於 Animal.prototype,它也如預期繼承了 name、color,以及掛在原型上的 type 屬性與 msg 方法。這段程式碼展示了兩個關鍵技巧:

· this.name = name 為每個物件都加上自己的 name 屬性,有點像類實例封裝的資料值。

· Animal.prototype.type 與 Animal.prototype.msg 則是往原型物件上掛屬性與方法。cat 能用 cat.type 與 cat.msg(),靠的正是 prototype 機制:建立 cat 時它的內部原型關聯到了 Animal.prototype,當 cat 自身找不到 type 或 msg,便沿鏈找到 Animal.prototype 上。

它是函式,為何被當成「類」?

JavaScript 有個約定俗成的慣例:建構函式(或稱類函式)的首字母大寫。老實說,Animal 與其他普通函式並無本質差異,唯一的區別是呼叫時加了 new,把「普通呼叫」變成了「建構函式呼叫」。

還有個更重要的原因,來看程式碼:

function Animal(name, color) {
  this.name  = name;
  this.color = color;
}
Animal.prototype.type = "動物";
Animal.prototype.msg = function () {
  alert("I am " + this.name + ", my color is " + this.color);
};

var cat = new Animal("cat", "black");
console.log(cat.constructor === Animal); // true

新建的 cat 上取到的 constructor 全等於 Animal,看起來就像「cat 是由 Animal 建構出來的」。但真相是:cat 並沒有自己的 constructor 屬性,這個屬性同樣是沿原型鏈委託到 Animal.prototype 上取得的,而 Animal.prototype.constructor 預設指回 Animal。驗證一下:

function Foo(){ name: 'x' }
Foo.prototype = {};            // 整體覆寫原型,constructor 隨之遺失

var foo = new Foo();
console.log(foo.constructor === Foo);    // false
console.log(foo.constructor === Object); // true

foo 上不存在 constructor,於是往原型鏈上找;但被覆寫後的 Foo.prototype 也沒有 constructor,只好繼續往上,直到鏈的終點 Object.prototype——那裡有 constructor,且指向內建的 Object()。所以「foo 是由 Foo 建構出來的」這個說法,在這種寫法下並不成立。這也是為什麼整體覆寫 prototype 之後,通常要補一句 Foo.prototype.constructor = Foo;。

原型繼承與類繼承的差別

在靜態類語言中,類可以被「複製」多次,就像用模具製造物件:實例化一個類時,會把類的行為複製一份到實體物件中。但在 JavaScript 裡並不存在這種複製機制——建立實例時,實例的 prototype 只是被關聯到建構函式的原型物件上。

用前面的例子來說,cat 的 prototype 被關聯到 Animal.prototype,當我們存取 cat.type 時是沿鏈查找,而不是另外複製一份存到 cat 上:

function Foo(){ name: 'x' }
Foo.prototype = { friends: ['y', 'z', 'c'] };

var foo = new Foo();
console.log(foo.friends); // ["y", "z", "c"]

Foo.prototype.friends.push('a'); // 往原型上的陣列追加一項
console.log(foo.friends);        // ["y", "z", "c", "a"]

這個示範也順帶暴露了原型繼承最經典的坑:若原型上的屬性是參考型別(陣列、物件),所有實例會共用同一份,改動一個會影響全部。這正是「經典繼承帶來的引用汙染」問題。

繼承的幾種寫法

JavaScript 中繼承方式很多:原型繼承、借用建構函式、組合繼承、寄生繼承等等。

假設有兩個「類」SuperType 與 SubType,要讓 SubType 繼承 SuperType,就必須修改 SubType 的原型。常見寫法有:

· SubType.prototype = SuperType.prototype

· SubType.prototype = new SuperType()

但我更推薦下面這一種:

function Foo(name) {
  this.name = name;
}
Foo.prototype.sayName = function () {
  console.log(this.name);
};

function Bar(name, label) {
  Foo.call(this, name); // 借用 Foo 建構函式,處理 name
  this.label = label;
}

// 建立 Bar.prototype 物件並關聯到 Foo.prototype 上
Bar.prototype = Object.create(Foo.prototype);
Bar.prototype.constructor = Bar; // 補回 constructor 指向

// 在 Bar.prototype 上新增方法
Bar.prototype.sayLabel = function () {
  console.log(this.label);
};

var a = new Bar('x', 'person');
a.sayName();  // x
a.sayLabel(); // person

核心那一行是 Bar.prototype = Object.create(Foo.prototype):它會憑空建立一個新物件,並把這個新物件的內部 prototype 關聯到你指定的物件上。

為什麼要推薦它?

· Bar.prototype = Foo.prototype 並沒有建立新物件,只是讓 Bar.prototype 直接引用 Foo.prototype。之後在 Bar.prototype 上加屬性或方法,等於改動了 Foo.prototype 本身,會連帶影響所有後代——顯然不是我們要的。

· Bar.prototype = new Foo() 確實建立了新物件,但過程會真的去執行 Foo 這個函式。若 Foo 裡有一些「副作用」程式碼——往 this 掛屬性、寫日誌、改全域狀態——同樣會污染後代。

所以我們需要一個「乾淨的關聯物件」,而 Object.create 正好勝任:它只做關聯,不執行建構函式。

此外 ES6 還新增了輔助函式 Object.setPrototypeOf,可以直接修改物件的原型關聯:

Object.setPrototypeOf(Bar.prototype, Foo.prototype);

結束語:這篇博文醞釀了挺久。原型鏈可以展開細講的點很多,枝節龐雜,一直想把它們串成一條線,也反映出自己對這些知識的理解還不夠透徹。若文中有謬誤之處,歡迎指正;若這篇筆記對你有些許幫助,就點個推薦吧。

參考資料:《你不知道的 JavaScript》

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