對象是 JavaScript 裡最關鍵的概念之一,能否真正理解它,直接決定你對整個語言體系的地基是否牢靠。說白了,JavaScript 就是一群對象在互相打交道。
最基礎的方式,和大多數語言一樣:沒對象就 new 一個。
var gf = new Object();
gf.name = "tangwei";
gf.bar = "c++";
gf.sayWhat = function () {
console.log(this.name + " said: love you forever");
};
顯然上面的寫法略顯繁瑣,作為腳本語言,JS 提供了更簡潔的字面量形式:
var gf = {
name: "tangwei",
bar: "c++",
sayWhat: function () {
console.log(this.name + " said: love you forever");
}
};
如果需要批量創建大量屬性結構相似的對象,一個個定義顯然不現實,於是有了工廠模式:
function createGf(name, bar) {
var o = new Object();
o.name = name;
o.bar = bar;
o.sayWhat = function () {
alert(this.name + " said: love you forever");
};
return o;
}
var gf1 = createGf("bingbing", "d");
var gf2 = createGf("mimi", "a");
工廠模式解決了批量創建的問題,但所有對象都是 Object 造出來的,無法區分具體類型。構造函數模式填補了這個空白:
function Gf(name, bar) {
this.name = name;
this.bar = bar;
this.sayWhat = function () {
alert(this.name + " said: love you forever");
};
}
var gf1 = new Gf("vivian", "f");
var gf2 = new Gf("vivian2", "f");
約定俗成,構造函數首字母大寫。使用 new 調用時,JS 會創建新對象、把構造函數的作用域賦給它、執行函數體,並回傳這個對象。
問題很快浮現:兩個實例中的 sayWhat 並不是同一個 Function 實例。
console.log(gf1.sayWhat == gf2.sayWhat); // false
調用同一個方法卻聲明了不同實例,白白浪費內存。把函數提到外面可以緩解:
function Gf(name, bar) {
this.name = name;
this.bar = bar;
this.sayWhat = sayWhat;
}
function sayWhat() {
alert(this.name + " said: love you forever");
}
但新問題是:sayWhat 被掛到了全局作用域,而它其實無法獨立調用,封裝性蕩然無存。要優雅地解決,得請出原型對象。
創建一個函數時,該函數會自帶 prototype 屬性,指向它的原型對象。通俗地說,原型對象就是內存中為其他對象提供共享屬性和方法的對象。
function Gf() {}
Gf.prototype.name = "vivian";
Gf.prototype.bar = "c++";
Gf.prototype.sayWhat = function () {
alert(this.name + " said: love you forever");
};
var gf1 = new Gf();
gf1.sayWhat();
var gf2 = new Gf();
此時所有實例共享同一份屬性和方法,gf1 和 gf2 訪問的是同一份數據。除了我們添加的屬性,原型對象還有一個內置的 constructor 屬性,指向包含 prototype 的函數。
查找規則可以這樣記:所有對象都有一個原型對象;原型對象上的 constructor 指回構造函數;實例內部還有一個指針指向原型(Firefox 中表現為 __proto__)。訪問屬性時,先問實例自己有沒有,沒有就沿原型鏈向上查找。
function Gf() {}
Gf.prototype = {
name: "vivian",
bar: "c++",
sayWhat: function () {
alert(this.name + " said: love you forever");
}
};
這裡有個容易忽略的細節:每定義一個函數,JS 會同時為它創建 prototype 對象並自動掛上 constructor。我們整體覆寫 prototype,等於丟掉了原來那個 constructor,於是:
var gf1 = new Gf(); console.log(gf1.constructor == Gf); // false console.log(gf1.constructor == Object); // true
如果對 constructor 有依賴,顯式補回去即可:
Gf.prototype = {
constructor: Gf,
name: "vivian",
bar: "c++",
sayWhat: function () {
alert(this.name + " said: love you forever");
}
};
var gf1 = new Gf();
console.log(gf1.constructor == Gf); // true
純原型模式最大的特點是所有實例共享屬性——這是優點也是「雙刃劍」。實戰中我們通常希望每個實例擁有自己獨立的數據,這也是很少有人單獨使用原型模式的原因。
最佳實踐是各取所長:用構造函數定義實例自有屬性,用原型定義共享的方法。
function Gf(name, bar) {
this.name = name;
this.bar = bar;
}
Gf.prototype = {
constructor: Gf,
sayWhat: function () {
alert(this.name + " said: love you forever");
}
};
var gf1 = new Gf("vivian", "f");
var gf2 = new Gf("vivian1", "c");
這樣 gf1 與 gf2 的屬性互不干擾,方法又只存在一份。這正是實戰中最主流的對象定義方式,很多 JS 庫(如 Bootstrap)默認採用的也是這套模式。
further 一點,在支持 ES6 之後,class 語法糖讓同樣的結構更易讀,但其底層依然基於原型:
class Gf {
constructor(name, bar) {
this.name = name;
this.bar = bar;
}
sayWhat() {
alert(this.name + " said: love you forever");
}
}