JavaScript 的物件,和傳統物件導向語言裡的物件幾乎沒有相似之處。
在傳統 OO 語言中,你要先有類別這個模板,類別裡定義好屬性與操作方法,然後透過new 執行個體化,最後靠物件之間的協作完成功能,再靠功能的集合完成整個系統。JavaScript 裡沒有類別這種東西——但憑藉語言本身的動態性,我們完全可以先建一個空物件,再一個屬性一個屬性地把它補完。
JSON 是 JavaScript 的物件字面值語法,也就是物件的另一種表示方法。用了 JSON,中間變數可以省掉,程式碼結構更清楚、也更直觀。你可以動態地組出物件,不必繞道類別去個體化,編碼效率因此大幅提升。
JavaScript 物件其實就是屬性的集合,而這裡的「集合」與數學意義上的集合等價:確定性、無序性、互異性。給定一個物件,你能明確判斷某個屬性是不是屬於它;屬性之間沒有順序;屬性彼此相異(若同名,後宣告的會覆蓋先宣告的)。
一般情況下,我們宣告物件時它往往只是個空集合,什麼屬性都沒有。透過不斷添加屬性,它才慢慢長成一個功能完整的物件——不必先建類別再個體化。這樣做的好處是靈活性極高,屬性可以任意增刪。
如果你有 Python 或其他動態語言的經驗,理解 JavaScript 物件會輕鬆很多。JavaScript 物件本身就是一個字典(dictionary),等同 Java 的 Map,也有人叫它關聯陣列——用鍵關聯一個值,而這個值本身又可以是一個物件。依此類推,JavaScript 物件足以表達任意複雜的資料結構。
屬性由鍵值對組成:屬性名與屬性值。屬性名是字串,值可以是任何 JavaScript 物件(在 JavaScript 裡,一切皆物件,函式也不例外)。
// 宣告一個物件
var jack = new Object();
jack.name = "jack";
jack.age = 26;
jack.birthday = new Date(1984, 4, 5);
// 宣告另一個物件
var address = new Object();
address.street = "Huang Quan Road";
address.xno = "135";
// 把 address 指派給 jack 的 addr 屬性
jack.addr = address;
這種寫法和傳統 OO 語言涇渭分明,卻給了我們極大的自由去定制物件的行為。
讀取屬性有兩種方式,常見的是點運算子:
var ja = jack.addr;
另一種是中括號:
ja = jack["addr"];
後者存在的理由,是為了應付屬性名本身含點(.)的情況——這在 JavaScript 中是合法的。比方說有個屬性叫 foo.bar,你寫 jack.foo.bar,直譯器會誤以為是 foo 底下有個 bar,於是取不到值;改用 jack["foo.bar"] 就沒問題。所以寫通用工具庫時,對使用者的輸入最好不做任何假設,用中括號形式永遠是安全的。
讀到這裡你大概已經發現,物件的屬性和我們先前講的變數行為幾乎一致。事實上,它們就是同一回事。
JavaScript 引擎初始化時會建立一個全域物件,在瀏覽器環境中就是 window。要在其他環境下引用它,只要在頂層作用域(所有函式宣告之外的地方)寫:
var global = this;
我們在頂層作用域宣告的變數,會作為全域物件的屬性被保存。從這個角度看,變數就是屬性。所以瀏覽器端常見的這類程式碼:
var v = "global";
var array = ["hello", "world"];
function func(id){
var element = document.getElementById(id);
// 對 element 做一些操作
}
其實等同於:
window.v = "global";
window.array = ["hello", "world"];
window.func = function(id){
var element = document.getElementById(id);
// 對 element 做一些操作
}
原型(prototype)是 JavaScript 特有的概念。透過原型,JavaScript 得以建立傳統 OO 語言中的繼承,從而表達物件的層次關係。
JavaScript 本身就是基於原型的:每個物件都有一個 prototype 屬性,而這個 prototype 本身也是物件,因此它也有自己的原型——層層相扣,構成一條鏈。
存取某個屬性時,直譯器會沿著這條鏈自下而上查找,找到就回傳對應的值;若一直找到原型為 null 的物件(JavaScript 最基礎的 Object,其 prototype 即為 null)都沒有這個屬性,就回傳 undefined。
實際看個例子:
// 宣告一個 base
function Base(name){
this.name = name;
this.getName = function(){
return this.name;
}
}
// 宣告一個 child
function Child(id){
this.id = id;
this.getId = function(){
return this.id;
}
}
// 把 Child 的原型指向一個新的 Base 物件
Child.prototype = new Base("base");
// 個體化一個 Child
var c1 = new Child("child");
// c1 本身就有 getId
print(c1.getId());
// c1 從原型鏈上「繼承」到了 getName
print(c1.getName());
輸出:
child
base
因為原型鏈是自下而上遍歷,最先遇到的屬性值最先被回傳——這套機制正是「覆寫」得以成立的原理。
JavaScript 裡最容易讓人困惑的莫過於 this。在傳統 OO 語言中,this 在類別內宣告,代表物件本身;而在 JavaScript 中,this 代表當前上下文,也就是呼叫者的引用。
var jack = {
name : "jack",
age : 26
}
var abruzzi = {
name : "abruzzi",
age : 26
}
function printName(){
return this.name;
}
print(printName.call(jack));
print(printName.call(abruzzi));
輸出:
jack
abruzzi
關鍵在於:this 的值不是由函式如何被宣告決定,而是由函式如何被呼叫決定。這一點與傳統物件導向語言涇渭分明。call 是 Function 上的一個方法,後續章節會詳談。
物件是 JavaScript 的基礎,我們用 JavaScript 寫程式,本質上就是在操作物件。建立方式有三種:
◆ 用 new 操作 Object,得到一個新物件,再動態添加屬性,從無到有
◆ 定義物件的「類」(即原型),再用 new 大量製造
◆ 使用 JSON(下一節詳談)
這裡先講第二種:
// 定義一個「類」,Address
function Address(street, xno){
this.street = street || 'Huang Quan Road';
this.xno = xno || 135;
this.toString = function(){
return "street : " + this.street + ", No : " + this.xno;
}
}
// 定義另一個「類」,Person
function Person(name, age, addr){
this.name = name || 'unknown';
this.age = age;
this.addr = addr || new Address(null, null);
this.getName = function(){return this.name;}
this.getAge = function(){return this.age;}
this.getAddr = function(){return this.addr.toString();}
}
// 用 new 建立兩個互相獨立的物件
var jack = new Person('jack', 26, new Address('Qing Hai Road', 123));
var abruzzi = new Person('abruzzi', 26);
print(jack.getName());
print(jack.getAge());
print(jack.getAddr());
print(abruzzi.getName());
print(abruzzi.getAge());
print(abruzzi.getAddr());
輸出:
jack
26
street : Qing Hai Road, No : 123
abruzzi
26
street : Huang Quan Road, No : 135
JSON 全名是 JavaScript Object Notation,也就是用字面值表示物件。從簡單到複雜都能用這套寫法:
var obj = {
name : "abruzzi",
age : 26,
birthday : new Date(1984, 4, 5),
addr : {
street : "Huang Quan Road",
xno : "135"
}
}
比起上面那個例子,這寫法簡潔太多:沒有冗餘的中間變數,物件的結構一眼就看懂。多數有經驗的 JavaScript 工程師都偏好這種表示法,jQuery、ExtJS 等工具庫更是大量使用。
JSON 也早已成為前端與伺服器之間的資料交換格式:前端透過 Ajax 送出 JSON,後端解析還原成自己的物件,處理完再把 JSON 回傳。兩端共用同一種格式,出錯的機率自然降低。
而且 JSON 的結構本身可以遞迴,也就是說它能表達任意複雜的資料形式。寫法很簡單:一對大括號包住鍵值對,鍵與值之間用冒號隔開,值可以是任何 JavaScript 物件——String、Boolean、Number、Null 這類簡單型別,也可以是 Date、Object 或其他自訂物件。
另一個很實用的場景:函式需要回傳多個值時。傳統 OO 語言得先組織一個物件再回傳,JavaScript 完全不必這麼麻煩。
function point(left, top){
this.left = left;
this.top = top;
// handle the left and top
return {x: this.left, y: this.top};
}
直接動態組一個匿名物件丟回去:
var pos = point(3, 4);
// pos.x = 3;
// pos.y = 4;
用 JSON 回傳的物件可以有任意複雜的結構,甚至能包含函式。
實務上經常需要遍歷一個物件,而事先對它的內容一無所知。JavaScript 提供了 for...in 這項語法糖:
for(var item in json){
// item 是鍵
// json[item] 是值
}
這個模式非常有用。比方說要替某個頁面元素設定一批事先無法預知的屬性:
var style = {
border:"1px solid #ccc",
color:"blue"
};
然後動態套到 DOM 元素上:
for(var item in style){
// 這裡用 jQuery 的選擇器
$("div#element").css(item, style[item]);
}
當然 jQuery 有更好的做法,這裡只是舉例。重點是:在替 $("div#element") 添加屬性時,我們對 style 的結構是完全不清楚的。
反過來也一樣。要收集使用者的自訂設定時,可以公開一個 JSON 物件,讓使用者把想調整的項目填進去,我們的程式再統統處理:
function customize(options){
this.settings = $.extend(default, options);
}
物件思維一旦建立,你會發現 JavaScript 裡幾乎所有問題,最後都能化約成「往這個屬性集合裡放什麼」。