JavaScript 的原型概念總讓人困惑,即使經驗豐富的開發者甚至語言作者,都常給出有限的解釋。問題往往出在我們最早「學到」的版本:原型總是跟 new、constructor 以及令人頭痛的 prototype 屬性綁在一起。其實原型是個相當單純的概念——只要先把那些先入為主的印象放掉,從頭看起。
原型是一個「被其他物件用來繼承屬性的物件」。
任何物件都可以當原型嗎?是的。
哪些物件有原型?每個物件都有一個預設原型,而原型本身也是物件,因此它也有自己的原型,一層接一層往上。唯一的例外是預設的物件原型,它位於每條原型鏈的頂端。
那什麼是物件?在 JavaScript 中,物件是以鍵值對保存的任意無序集合;只要不是原始型別(undefined、null、boolean、number、string),它就是物件。
這正是最大的誤會來源。請先把「prototype 屬性」的印象忘掉——一個物件真正的原型是它內部的 [[Prototype]]。ES5 提供了標準的讀取方式 Object.getPrototypeOf(),Firefox、Safari、Chrome、IE9 都支援;此外除 IE 外,多數瀏覽器也支援非標準的 __proto__。
var a = {};
Object.getPrototypeOf(a); // [object Object] (IE8 以下失敗)
a.__proto__; // [object Object] (IE 失敗)
a.constructor.prototype; // [object Object] (所有瀏覽器)
原始型別也是如此:訪問原始值的原型時,它會被強制轉為物件。
false.__proto__ === Boolean(false).__proto__; // true
JavaScript 不區分建構函式與其他函式,所以每個函式都有 prototype 屬性;而非函式則沒有。
Math.max.prototype; // [object Object] ← Math.max 是函式,所以有 Math.prototype; // null ← Math 不是函式,所以沒有
定義就清楚了:函式的 prototype 屬性,是當這個函式被當作建構函式呼叫時,賦給新物件的原型。
非常重要的一點:函式的 prototype 屬性與函式「本身」的原型毫無關係。
var A = function (name) { this.name = name; };
A.prototype == A.__proto__; // false
A.__proto__ == Function.prototype; // true —— A 的原型是 Function.prototype
// 建構函式:this 作為新物件被返回,其 [[Prototype]] 被設為建構函式的 prototype
var Circle = function (radius) {
this.radius = radius;
// this.__proto__ = Circle.prototype; (隱式執行,僅供說明)
};
// 擴充 Circle 的預設 prototype,因此每個由它建立的實例都繼承到這個方法
Circle.prototype.area = function () {
return Math.PI * this.radius * this.radius;
};
var a = new Circle(3), b = new Circle(4);
a.area().toFixed(2); // 28.27
b.area().toFixed(2); // 50.27
原型對象的屬性只定義一次,就被所有引用它的實例共享——這是原型機制在效能與可維護性上的價值所在,也是建構函式存在的原因:它提供了一個跨瀏覽器、在建立實例時自動接上共用原型的便利機制。
要分兩種情況。若是修改既有 prototype 的屬性,答案是會,因為 a.__proto__ 指向的就是那個物件:
var A = function (name) { this.name = name; };
var a = new A('alpha');
a.name; // 'alpha'
A.prototype.x = 23;
a.x; // 23
但若是整個替換 prototype 屬性,既有實例的 __proto__ 仍指向舊物件,因此拿不到新的屬性:
var A = function (name) { this.name = name; };
var a = new A('alpha');
A.prototype = { x: 23 };
a.x; // undefined
就是一個帶有 constructor 屬性的物件:
var A = function () {};
A.prototype.constructor == A; // true
var a = new A();
a.constructor == A; // true(a 的 constructor 繼承自原型)
若 A 的 prototype 屬性出現在 a 的原型鏈上,a instanceof A 就回傳 true。這也意味著我們可以「騙」過 instanceof:
var A = function () {};
var a = new A();
a.__proto__ == A.prototype; // true
a instanceof A; // true
a.__proto__ = Function.prototype; // 改掉 a 的原型
a instanceof A; // false
既然每個建構函式都有 prototype 屬性,本地建構函式如 String、Array 也不例外。用「擴充而非替換」的方式,就能替該型別的所有物件加上新方法:
String.prototype.times = function (count) {
return count < 1 ? '' : new Array(count + 1).join(this);
};
"hello!".times(3); // "hello!hello!hello!"
"please...".times(6); // "please...please...please...please...please...please..."
不過要提醒:擴充內建原型在多人協作或引入第三方函式庫時容易造成命名衝突與難以追蹤的 bug,除了 polyfill 之外,實務上較建議用 ES6 的 class 或純函式來組織程式。
因為每個物件與每個原型都有自己的原型,把它們串起來就成了原型鏈,鏈的終端永遠是 Object.prototype,再上去就是 null:
a.__proto__ = b;
b.__proto__ = c;
c.__proto__ = {}; // 預設物件
{}.__proto__.__proto__; // null
屬性讀取時,JavaScript 會從物件自身開始沿原型鏈往上逐節點尋找,找到就回傳,走到終點仍找不到則回傳 undefined。
但賦值時原型鏈不會起作用:a.foo = 'bar' 只會在 a 自身建立 foo 屬性。想改原型上的屬性,必須明確定位到原型物件本身。
今天寫 JavaScript 幾乎都會用 class 語法,但它本質上就是原型繼承的語法糖:
class Circle {
constructor(radius) { this.radius = radius; }
area() { return Math.PI * this.radius ** 2; }
}
它與 Circle.prototype.area = function () {...} 完全等價。理解原型,才能真正看懂 class 背後發生的事,也才能解釋為什麼類別方法不屬於單一實例、為什麼 super 能找到父類別的實作。