在 Java、C++、PHP 等物件導向語言中,建構函式是基本配備。JavaScript 也有,但它的本質有點特別:建構函式首先就是一個普通函式,只是可以用 new 運算子呼叫,並因此產生一個特定類型的物件。
// Benjamin 是一個建構函式
var benjamin = new Benjamin("zuojj", "male");那這個实例化過程具體做了什麼?
function Benjamin(username, sex) {
this.username = username;
this.sex = sex;
}
var benjamin = new Benjamin("zuojj", "male");
// 輸出 Benjamin {sex: "male", username: "zuojj"}
console.log(benjamin);Bemjamin 這個函式做的事只有一件:把傳進來的參數賦值給 this。之所以能這樣寫,是因為當函式被 new 呼叫時,函式內部的 this 會被指向 new 所建立的那個新物件。
換句話說,上面的程式等同於:
benjamin = {
"username": "zuojj",
"sex": "male"
}既然最終結果只是一個物件字面量,何必繞這一圈?原因有三。
所有透過同一個建構函式產生的物件,都具備相同的基礎結構。當你建立幾百個使用者物件時,欄位名稱不會有拼錯或漏掉的風險。
function Benjamin(username, sex) {
this.username = username;
this.sex = sex;
}
var benjamin = new Benjamin("zuojj", "male");
var ben = {
"username": "zuojj",
"sex": "male"
}
// 輸出 true
console.log(benjamin instanceof Benjamin);
// 輸出 false
console.log(ben instanceof Benjamin);用字面量建立的 ben 與用建構函式建立的 benjamin 內容完全一樣,但 instanceof 的結果不同。這個標記讓型別判斷成為可能。
function Benjamin(username, sex) {
this.username = username;
this.sex = sex;
}
Benjamin.prototype.getName = function() {
return this.username;
}
var benjamin = new Benjamin("zuojj", "male");
var ben = new Benjamin("lemon", "female");
// 輸出 zuojj
console.log(benjamin.getName());
// 輸出 lemon
console.log(ben.getName());方法定義在 prototype 上,所有實例共用同一份,不必每建一個物件就複製一次函式。這是原型繼承最直接的效益。
是否使用 new,對 this 的影響極大。少了 new,函式就以普通函式身分被呼叫,此時 this 指向全域物件(瀏覽器中的 window、Node 中的 global),非嚴格模式下你會不知不覺污染全域變數。
這也是為什麼慣例要求建構函式名稱首字母大寫——它是一個視覺提示,提醒呼叫者別忘了 new。
若函式沒有顯式 return,則隱式回傳 this(也就是新建立的物件)。若有顯式 return,行為會依回傳值的型別分歧:
function Bar() {
return 2;
}
var bar = new Bar();
// 回傳新建立的物件
// 輸出 Bar {}
console.log(bar);
function Test() {
this.value = 2;
return {
foo: 1
};
}
var test = new Test();
// 回傳函式指定的物件
// 輸出 Object {foo: 1}
console.log(test);規則是:只有當顯式回傳的是一個物件時,才會取代 new 建立的物件。回傳基本型別(數字、字串、布林)會被忽略。
function Bar() {
return 2;
}
var bar = new Bar();
function BarN() {
return new Number(2);
}
var barn = new BarN();
// 輸出 true
console.log(bar.constructor === Bar);
// 輸出 Number {}
console.log(barn);
// 輸出 false
console.log(barn.constructor === BarN);
// 輸出 true
console.log(barn.constructor === Number);
/* -------------------------------------- */
function Test() {
this.value = 2;
return {
foo: 1
};
}
var test = new Test();
// 輸出 undefined
console.log(test.value);
// 輸出 1
console.log(test.foo);這段對照說明了兩件事:
a) new Bar() 回傳的是新物件,而非數字 2,所以 bar.constructor === Bar 成立。但 new Number(2) 回傳的是 Number 的包裝物件,因此 barn.constructor === Number,而非 BarN。
b) new Test() 得到的是函式明確回傳的物件,不是 new 建立的那個。所以 test.value 是 undefined(那是被丟掉的物件上的屬性),而 test.foo 才是 1。
ES6 的 class 語法本質上就是建構函式加原型的語法糖,但它強制要求用 new 呼叫,少了忘記 new 的風險:
class Benjamin {
constructor(username, sex) {
this.username = username;
this.sex = sex;
}
getName() {
return this.username;
}
}若要在 ES5 環境中防呆,可以在函式開頭檢查:
function Benjamin(username, sex) {
if (!(this instanceof Benjamin)) {
return new Benjamin(username, sex);
}
this.username = username;
this.sex = sex;
}理解 new 的四個步驟——建立空物件、把 this 指向它、執行函式本體、回傳該物件——就能解釋本文所有看似反直覺的行為。