物件是 JavaScript 的核心。要把語言學到位,繞不開幾件事:物件怎麼生出來、屬性怎麼讀寫與刪除、屬性背後有哪些隱藏特性、以及物件如何被序列化保存。本文按這幾條主線重新梳理一遍,順便把原型鏈、getter/setter、屬性描述符這些容易含糊的概念講清楚。
最直觀的寫法,用一組「名稱/值」構成映射表:
var point = { x: 0, y: 0 };
屬性名幾乎沒有約束,關鍵字或任意字串都能當屬性名,只是這種情況下得用引號包起來:
var empty = {};
var point = { x: 0, y: 0 };
var book = {
"main title": "Javascript",
"sub-title": "The definitive Guide",
"for": "all audience",
author: { firstName: "Davide", lastName: "Flanagan" }
};
直接量寫起來快,但可重複用性很差。同一份結構要在別的地方再來一遍、只是值不同,難道要複製一份程式碼?這正是下面兩種方式的價值所在。
new 會把傳入的函式當成建構函式(constructor)來呼叫:
function Person(){ /* 建構函式內容 */ }
var person = new Person();
語言核心的原始型別也都各自內建了建構函式:
var a = new Array();
var d = new Date();
var r = new RegExp("js");
談 create 之前得先談原型。除了 null,每個 JavaScript 物件都與另一個物件關聯,那個物件就是它的原型,物件會從原型繼承屬性。
用物件直接量建出來的物件,原型一律是 Object.prototype;用 new 建出來的物件,原型是建構函式 prototype 屬性的值——new Array() 的原型是 Array.prototype,new Date() 的原型是 Date.prototype。
Object.create() 接受兩個參數:第一個是原型物件,第二個可選,用來描述要一併定義的屬性。用法很簡單:
var o1 = Object.create({ x: 1, y: 2 });
傳入 null 可以造出完全沒有原型的物件,它不會繼承任何屬性,連 toString 都沒有:
var o2 = Object.create(null); // 沒有原型
想要一個普通的空物件,傳 Object.prototype 即可;想要自訂型別的物件,傳該建構函式的 prototype:
var o3 = Object.create(Object.prototype);
function Person(){ }
var o4 = Object.create(Person.prototype);
讀寫屬性有兩種語法:點(.)與方括號([])。用點的時候屬性名必須是合法識別符,不能是保留字,所以 o.for、o.class 這種寫法行不通。
var author = book.author; // 正確 var name = author.surname; // 正確 var title = book["main title"]; // 正確 var className = book.class; // 錯誤
object["property"] 看起來像陣列,只不過索引是字串而非數字,這種結構常被稱為關聯陣列(associative array),也叫雜湊、映射或字典。可以說,JavaScript 物件天生就是關聯陣列。
既然如此,語言也提供了 for/in 來遍歷屬性。下面用來累加一組持股的總市值:
function getvalue(portfolio){
var total = 0.0;
for (stock in portfolio){
var shares = portfolio[stock];
var price = getquote(stock);
total += shares * price;
}
return total;
}
物件既有自有屬性(own property),也有從原型繼承來的屬性。下面這個 inherit 函式示範了如何建立繼承關係:
function inherit(p){
if (p == null) throw TypeError(); // p 必須是物件
if (Object.create){
return Object.create(p); // 直接走原生方法
}
var t = typeof p;
if (t !== "object" && t !== "function") throw TypeError();
function f(){ }
f.prototype = p; // 把原型指向 p
return new f();
}
查詢物件 o 的屬性 x 時,若 o 本身沒有 x,就往 o 的原型找;原型也沒有,就繼續往原型的原型找,一路沿原型鏈上溯,直到找到 x,或碰到原型為 null 的物件為止。
var o = {}; // o 從 Object.prototype 繼承屬性
o.x = 1; // 定義 x
var p = inherit(o); // p 繼承 o 與 Object.prototype
p.y = 2; // 定義 y
var q = inherit(p); // q 繼承 p、o 與 Object.prototype
q.z = 3; // 定義 z
var s = q.toString(); // toString 來自 Object.prototype
q.x + q.y // => 3,x 與 y 分別繼承自 o 與 p
delete 用來刪除屬性:
delete book.author; delete book["main title"];
要注意兩點:delete 只能刪自有屬性,刪不掉繼承屬性;要刪繼承屬性,得回到定義它的原型物件上動手,而這會影響所有繼承自該原型的物件。刪除成功會回傳 true。
var o = { x: 1 };
delete o.x; // 刪除 x,回傳 true
delete o.x; // x 已不存在,什麼都沒做,仍回傳 true
delete o.toString; // 繼承屬性,刪不掉,回傳 true
// 可設定性為 false 的屬性刪不掉
delete Object.prototype; // 不可刪除
var x = 1;
delete this.x; // 不可刪除
function f(){ }
delete this.f; // 全域函式不可刪除
三種常見手段:in 運算子、hasOwnProperty()、propertyIsEnumerable()。
in 左側是屬性名,右側是物件,自有或繼承屬性命中就回傳 true:
var o = { x: 1 };
"x" in o; // true
"y" in o; // false
"toString" in o; // true,繼承而來
hasOwnProperty() 只認自有屬性,繼承屬性一律回傳 false:
var o = { x: 1 };
o.hasOwnProperty("x"); // true
o.hasOwnProperty("y"); // false
o.hasOwnProperty("toString"); // false,繼承屬性
propertyIsEnumerable() 是上一個的加強版,必須是自有屬性且可列舉才回傳 true:
var o = inherit({ y: 2 });
o.x = 1;
o.propertyIsEnumerable("x"); // true
o.propertyIsEnumerable("y"); // false,繼承而來
Object.prototype.propertyIsEnumerable("toString"); // false,不可列舉
通常用 for/in 遍歷,範圍包含自有與繼承屬性。內建方法不可列舉,但我們自己掛上去的屬性都可以:
var o = { x: 1, y: 2, z: 3 }; // 三個可列舉的自有屬性
o.propertyIsEnumerable("toString"); // false
for (p in o) console.log(p); // 輸出 x、y、z,不含 toString
若只想遍歷「自有且不是函式」的屬性,加兩道過濾即可:
for (p in o){
if (!o.hasOwnProperty(p)) continue;
if (typeof o[p] === "function") continue;
}
利用列舉還能實現淺複製:
/*
* 把 p 中可列舉的屬性複製到 o,並回傳 o
* 同名屬性會覆蓋 o 原有的值
* 此函式不處理 getter/setter
*/
function extend(o, p){
for (prop in p){
o[prop] = p[prop];
}
return o;
}
ES5 另外提供了兩個列舉屬性名稱的方法:Object.keys() 回傳可列舉的自有屬性名陣列;Object.getOwnPropertyNames() 則回傳所有自有屬性,不論是否可列舉。
屬性由名字、值和一組特性(attribute)構成。ES5 起,屬性值可以被一兩個方法取代,這兩個方法就是 getter 與 setter,這樣定義出來的屬性稱為「存取器屬性」(accessor property),與只有單一值的「資料屬性」(data property)相對。
存取器屬性沒有可寫性這一說。同時具備 getter 與 setter 是讀寫屬性;只有 getter 是唯讀屬性;只有 setter 是只寫屬性,而讀取只寫屬性永遠得到 undefined。
定義語法很輕巧,不寫 function 關鍵字,改用 get 或 set:
var o = {
data_prop: 1, // 資料屬性
get accessor_prop(){ /* 函式體 */ }, // 存取器屬性成對定義
set accessor_prop(value){ }
};
來看一個 2D 笛卡兒座標點的例子:x、y 是普通的資料屬性,r 與 theta 則是等效的極座標存取器屬性:
var p = {
x: 1.0,
y: 1.0,
// r 可讀可寫
get r(){ return Math.sqrt(this.x * this.x + this.y * this.y); },
set r(newValue){
var oldValue = Math.sqrt(this.x * this.x + this.y * this.y);
var ratio = newValue / oldValue;
this.x *= ratio;
this.y *= ratio;
},
// theta 唯讀,只有 getter
get theta(){ return Math.atan2(this.y, this.x); }
};
存取器屬性同樣可以被繼承。把 p 當成另一個「點」物件的原型,只需定義 x、y,r 與 theta 直接沿用:
var q = inherit(p); q.x = 1; q.y = 1; console.log(q.r); console.log(q.theta);
把 getter/setter 看成屬性的特性,再沿著這個思路把「值」也算進去,於是一個屬性就是「一個名字 + 四個特性」。
資料屬性的四個特性是:值(value)、可寫性(writable)、可列舉性(enumerable)、可設定性(configurable)。存取器屬性沒有值與可寫性,取而代之的是讀取(get)與寫入(set),再加上可列舉性與可設定性。
ES5 用「屬性描述符」物件來承載這四個特性。資料屬性的描述符帶 value、writable、enumerable、configurable;存取器屬性的描述符則用 get、set 取代前兩者。其中三個開關是布林值,get/set 是函式。
// 回傳 {value: 1, writable: true, enumerable: true, configurable: true}
Object.getOwnPropertyDescriptor({ x: 1 }, "x");
// 查詢存取器屬性
// 回傳 {get: /*func*/, set: undefined, enumerable: true, configurable: true}
Object.getOwnPropertyDescriptor(random, "octet");
// 繼承屬性與不存在的屬性都回傳 undefined
Object.getOwnPropertyDescriptor({}, "x");
Object.getOwnPropertyDescriptor({}, "toString");
從名稱就看得出來,這個方法只取自有屬性的描述符。想取得繼承屬性的特性,得沿原型鏈走一趟(Object.getPrototypeOf())。
要設定屬性特性,或讓新屬性一開始就帶有某些特性,用 Object.defineProperty(),三個參數依序是物件、屬性名、描述符物件:
o.x; // => 1,屬性存在但不可列舉
Object.keys(o); // => []
// 把 x 改成唯讀
Object.defineProperty(o, "x", { writable: false });
o.x = 2; // 非嚴格模式靜默失敗,嚴格模式拋 TypeError
// x 仍可設定,所以能這樣改回來
Object.defineProperty(o, "x", { value: 2 });
o.x; // => 2
// 把資料屬性改成存取器屬性
Object.defineProperty(o, "x", { get: function(){ return 0; } });
o.x; // => 0
要一次處理多個屬性,用 Object.defineProperties():第一個參數是目標物件,第二個參數是描述符的映射表。
var p = Object.defineProperties({}, {
x: { value: 1, writable: true, enumerable: true, configurable: true },
y: { value: 2, writable: true, enumerable: true, configurable: true },
r: {
get: function(){ return Math.sqrt(this.x * this.x + this.y * this.y); },
enumerable: true,
configurable: true
}
});
ES5 定案之前,多數 JavaScript 實作早就支援物件直接量裡的 get/set 寫法,並各自提供了非標準的存取介面,一共四個方法,掛在物件原型上:
· __lookupGetter__() 與 __lookupSetter__():取得指定名稱屬性的 getter 與 setter。
· __defineGetter__() 與 __defineSetter__():定義 getter 與 setter,第一個參數是屬性名,第二個是函式。
var o = {};
o.__defineGetter__("x", function(){ return 0; });
o.__defineSetter__("y", function(value){ console.log("set value:" + value); });
原型(prototype)、類(class)、可擴展性(extensible attribute)——這三者決定了物件如何繼承、屬於什麼型別、以及能不能再被擴充。
原型屬性用於繼承,日常口語裡說的「o 的原型」就是它。前面提的三種建立方式,分別對應三種原型來源:直接量用 Object.prototype,new 用建構函式的 prototype,Object.create() 用第一個參數。
ES5 可以用 Object.getPrototypeOf() 查原型;ES3 沒有等效函式,只能寫 o.constructor.prototype。
要判斷某物件是否在另一物件的原型鏈上,用 isPrototypeOf():
var p = { x: 1 };
var o = Object.create(p);
p.isPrototypeOf(o); // => true,o 繼承自 p
Object.prototype.isPrototypeOf(o); // => true,p 繼承自 Object.prototype
Mozilla 系引擎另外暴露了 __proto__ 屬性可直接讀寫原型,但 IE 與 Opera 不支援,實務上不建議使用。
類屬性是一個字串,用來表示物件的型別資訊。ES3 與 ES5 都沒有提供設定方法,只能間接查詢:呼叫預設的 toString() 會得到 [object class] 這樣的字串,取出第 8 個字元到倒數第 2 個字元之間的內容即可。麻煩的是很多物件都改寫了 toString,因此得用 Function.call() 間接呼叫最原始的版本:
function classof(o){
if (o === null) return "Null";
if (o === undefined) return "Undefined";
return Object.prototype.toString.call(o).slice(8, -1);
}
可擴展性表示能否替物件添加新屬性。內建物件與自訂物件預設都是可擴展的,ES5 起可以把它鎖住:
· Object.seal():設為不可擴展,並把所有自有屬性設為不可設定。此後既不能加屬性,也不能刪除或重新設定既有屬性。
· Object.isSealed():檢測物件是否被封閉。
· Object.freeze():比 seal 更嚴格,除了上述效果,還把所有自有資料屬性設為唯讀(帶 setter 的存取器屬性不受影響,仍可透過賦值觸發)。
· Object.isFrozen():檢測物件是否被凍結。
序列化就是把物件狀態轉成字串,反之則是把字串還原成物件。ES5 內建了 JSON.stringify() 與 JSON.parse(),兩者都以 JSON 作為交換格式:
o = { x: 1, y: { z: [false, null, ""] } };
s = JSON.stringify(o); // {"x":1,"y":{"z":[false,null,""]}}
p = JSON.parse(s); // p 是 o 的深拷貝
JSON 語法是 JavaScript 語法的子集,表達力有限。物件、陣列、字串、有限數字、true、false、null 可以正常序列化與還原;NaN、Infinity、-Infinity 序列化後都會變成 null;函式、RegExp、Error 物件與 undefined 則無法序列化還原。
· toString():回傳代表該物件值的字串。不少型別都改寫過它,例如 Array.toString()、Date.toString()、Function.toString()。
· toJSON():Object.prototype 其實沒有定義這個方法,但 JSON.stringify() 在序列化時會優先查找並呼叫它,讓自訂物件有機會決定自己的序列化形式。
· valueOf():與 toString 類似,但用途是當 JavaScript 需要把物件轉成某種原始值(尤其是數字)時呼叫。有些內建型別自訂了實作,例如 Date.valueOf()。