本來要接著寫「由淺入深表達式」系列的最後一篇,但最近團隊突然忙了起來。喜歡那個系列的朋友別擔心,已經在寫了。工作過程中發現,大家對 JavaScript 的一些基本原理普遍存在或多或少的誤解,因此決定先花點時間把基礎知識整理出來分享。一開始打算寫成一篇,寫著寫著發現內容越來越多,於是變成了系列。
系列目錄:
本篇重點:
什麼是物件
可以把 JavaScript 的物件理解為一組無序的鍵值對,類似 C# 的 Dictionary<string, Object>。Key 是屬性名,value 可以是三種類型:
var o = new Object();
o["name"] = "jesse"; // 基本值作為屬性
o["location"] = { // 物件作為屬性
"city": "Shanghai",
"district": "minhang"
};
o["sayHello"] = function () { // 函式作為屬性
alert("Hello, I am " + this.name + " from " + this.location.city);
}
o.sayHello();
遍歷屬性
C# 可以用 foreach 遍歷 Dictionary,那 JavaScript 呢?
for (var p in o) {
alert('name: ' + p + ' type: ' + typeof o[p]);
}
// name: name type: string
// name: location type: object
// name: sayHello type: function
要注意這種寫法會把原型鏈上的屬性也一併遍歷出來,關於原型以及該如何過濾,後面會說明。
前面已經示範了兩種建立方式:
範例中的 o 用第一種方式,而 o 裡的 location 則是字面量。第一種方式也叫建構函式模式,因為 Object 本身就是一個建構函式。
工廠模式
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('Jesse', 29, 'Software Engineer');
var person2 = createPerson('Carol', 27, 'Designer');
這種模式有個問題:物件是在函式內部用 new Object() 建立的,跟 createPerson 這個函式沒有任何關係,因此無法判斷它究竟是哪個函式的實例。

建構函式模式
工廠模式沒有解決物件識別的問題。仔細想,Object() 其實也是函式,只不過前面加了 new 就變成建構函式。那麼其他函式前面加 new,同樣能產生該函式的實例。
function Person(name, age, job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){ alert(this.name); };
}
var p1 = new Person('Jesse', 18, 'coder');
alert(p1 instanceof Person); // true
this 在 JavaScript 中是個神奇的存在——它本身就是個物件。上一篇提到變數物件決定了當前執行環境中哪些屬性和函式可被存取,某種程度上可以把 this 視為該變數物件。最大的執行環境是全域環境,而 window 就是全域環境的變數物件,因此在全域環境中 this === window 會回傳 true。

每個函式都有自己的 this,但它代表的值取決於呼叫者。以下分情境說明。
在函式中
function f1(){ return this; }
f1() === window; // 全域物件(嚴格模式下為 undefined)
在物件方法中
var o = {
prop: 37,
f: function() { return this.prop; }
};
console.log(o.f()); // 37
在物件方法中,this 指向該實例物件。注意:不論函式在哪裡、何時、如何被定義,只要它是某物件實例的方法,this 就指向那個實例。
var o = { prop: 37 };
var prop = 15;
function independent() { return this.prop; }
o.f = independent;
console.log(independent()); // 15,this 指向全域
console.log(o.f()); // 37,this 指向 o
在建構函式中
用建構函式建立物件,正是利用了 this 的這個特性。建構函式中的 this 指向被實例化出來的物件。
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = function () { alert(this.name); };
}
var p1 = new Person('Jesse', 18, 'coder'); // this 指向 p1
var p2 = new Person('Carol', 16, 'designer'); // this 指向 p2
在 call 與 apply 中
用 call/apply 呼叫函式時,函式內的 this 會被綁定到指定的物件上。兩者主要差異是 apply 的第二個參數必須是陣列。
function add(c, d) { return this.a + this.b + c + d; }
var o = { a: 1, b: 3 };
add.call(o, 5, 7); // 第一個參數綁定 this → 1 + 3 + 5 + 7 = 16
add.apply(o, [10, 20]); // 第二個參數為陣列 → 1 + 3 + 10 + 20 = 34
在 bind 中
bind 存在於 Function.prototype 上,因此所有函式都有這個方法。呼叫 bind 會產生一個與原函式行為相同的新函式,但 this 固定指向傳入的第一個參數。
function f() { return this.a; }
var g = f.bind({ a: "azerty" });
console.log(g()); // azerty
var o = { a: 37, f: f, g: g };
console.log(o.f(), o.g()); // 37, azerty
在 DOM 事件處理器中
事件處理函式中的 this 指向觸發該事件的 DOM 元素。
<!-- HTML --> <html> <body> <div id="mydiv" style="width:400px; height:400px; border:1px solid red;"></div> <script type="text/javascript" src="essence.js"></script> </body> </html>
// JavaScript
function click(e) {
alert(this.nodeName);
}
var myDiv = document.getElementById("mydiv");
myDiv.addEventListener('click', click, false);
點擊該 div 時會顯示 DIV。

原型(prototype)是 JavaScript 中相當重要的概念。在討論它之前,先回顧建構函式模式:
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = function () { alert(this.name); };
}
var p1 = new Person('Jesse', 18, 'coder');
var p2 = new Person('Carol', 17, 'designer');
實例化 p1 時 this 指向 p1,實例化 p2 時指向 p2。也就是說,p1 與 p2 的 sayName 雖然作用相同,卻不是同一個函式。

這代表記憶體中存有多份拷貝,而非共享同一份參照。先不論是否符合物件導向思維,對記憶體而言這是浪費,而原型正是解法。
什麼是原型
JavaScript 中每個函式都有一個原型物件,它與普通物件沒有差別,只是預設帶有一個 constructor 屬性指向該函式。同時,所有該函式的實例都有一個內部連結指向這個原型物件。

上圖即為建構函式、建構函式原型與實例之間的關係。以 Person 為例,所有實例(p1、p2)都透過 prototype 連結指向 Person 的原型物件。如此一來,把方法掛到原型上,所有實例便會共用同一個方法。
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
Person.prototype.sayName = function () {
alert(this.name);
}
}
var p1 = new Person('Jesse', 18, 'coder');
var p2 = new Person('Carol', 17, 'designer');
alert(p1.sayName == p2.sayName); // true
什麼是原型鏈
還記得作用域鏈嗎?簡單說,在一個執行環境中存取某變數時,若當前環境找不到,就往包含它的外層環境找,一層層往外直到全域環境,這就是作用域鏈。
原型鏈的概念類似,只是場景換成物件實例:存取某屬性時,若實例本身沒有,就往它的原型找。而原型也是物件,它也有自己的原型,於是形成一條鏈。一直往上延伸到 Object 的原型物件為止——預設情況下,我們自訂函式的原型物件,其原型指向 Object 的原型,這就是為什麼自訂建構函式的實例能呼叫 toString、valueOf 等 Object 的方法。

利用原型實現繼承
JavaScript 的繼承主要就靠原型鏈。所有實例之所以都繼承自 Object,是因為預設情況下函式的原型物件之原型指向 Object。同理,我們可以自訂繼承關係:
function Person(name, age, job) {
this.name = name;
this.age = age;
}
Person.prototype.sayName = function () {
alert(this.name);
}
function Coder(language){
this.language = language;
}
Coder.prototype = new Person(); // 把 Coder 的原型指向 Person 實例,繼承 Person
Coder.prototype.code = function () {
alert('I am a ' + this.language + ' developer, Hello World!');
}
function Designer() { }
Designer.prototype = new Person(); // 同上
Designer.prototype.design = function () {
alert('其實我只是一個摳圖工而已。。。。');
}
var coder = new Coder('C#');
coder.name = 'Jesse';
coder.sayName(); // Jesse
coder.code(); // I am a C# developer, Hello World!
var designer = new Designer();
designer.name = 'Carol';
designer.sayName(); // Carol
designer.design(); // 其實我只是一個摳圖工而已。。。。
原型鏈中的常見問題
由於原型物件是以參照方式保存的,賦值時要特別小心,一不小心就會把先前的設定整組蓋掉。例如先寫原型方法、再實作繼承,原型方法就會消失:
function Coder(language){
this.language = language;
}
Coder.prototype.code = function () {
alert('I am a ' + this.language + ' developer, Hello World!');
}
Coder.prototype = new Person(); // 這裡會覆蓋上面所有的原型屬性和方法
var coder = new Coder('C#');
coder.name = 'Jesse';
coder.sayName();
coder.code(); // 抛出錯誤,找不到 code 方法
結論很直接:先指定原型(實作繼承),再往原型上掛方法;否則也要記得在覆寫原型後補回 constructor 指向。理解 this 的綁定規則與原型鏈的查找順序,是讀懂絕大多數 JavaScript 物件導向程式碼的兩把鑰匙。