什麼是屬性(Property),什麼是特性(Attribute)?這裡不做語義學上的區分:屬性就是組成物件的一個部分(廣義上也包含方法),是我們能透過程式碼存取的具體存在;特性則是被描述主體所具備的特徵,是為了便於理解概念的抽象存在,可以透過對應屬性外化。本節所講的「屬性的特性」,就是對屬性特徵的描述,主要來自 ECMA-262 第 5 版,規範以雙中括號表示無法直接存取的內部特性。
A、屬性類型
B、物件內部屬性
內部屬性主要是給規範與引擎實作者參考的,但了解它們有助於理解一些內部機制。例如為屬性賦值時,實作會呼叫 [[Put]];讀取值時呼叫 [[Get]]。
| 類別 | 名稱 | 規範 |
|---|---|---|
| 所有物件共有 | [[Prototype]] | Object/Null |
| [[Class]] | String | |
| [[Extensible]] | Boolean | |
| [[Get]] | SpecOp(propName) → any | |
| [[GetOwnProperty]] | SpecOp(propName) → Undefined|Property Descriptor | |
| [[GetProperty]] | SpecOp(propName) → Undefined|Property Descriptor | |
| [[Put]] | SpecOp(propName, any, Boolean) | |
| [[CanPut]] / [[HasProperty]] / [[Delete]] / [[DefaultValue]] / [[DefineOwnProperty]] | 屬性可寫判斷、存在判斷、刪除、取預設值、定義屬性 | |
| 個別物件特有 | [[PrimitiveValue]] | primitive(Boolean|Date|Number|String) |
| [[Construct]] | SpecOp(a List of any) → Object(new) | |
| [[Call]] | SpecOp(any, a List of any) → any|Reference(call) | |
| [[HasInstance]] | SpecOp(any) → Boolean(Function) | |
| [[Scope]] | Lexical Environment(Function) | |
| [[FormalParameters]] / [[ParameterMap]] / [[Match]] / [[TargetFunction]] 等 | Function 與 RegExp、Function.prototype.bind 專用 |
說明:
Object.getPrototypeOf(object) 取得(Firefox 中可用 __proto__)。Object.prototype.toString.call(value) == '[object Array]' 判斷是否為陣列。C、屬性的特性
| 內部特性 | 配置屬性 | 適用類型 | 預設值 | 含義 |
|---|---|---|---|---|
| [[Configurable]] | configurable | 數據屬性/訪問器屬性 | true | 能否用 delete 刪除並重新定義;能否修改屬性特性;能否改為訪問器屬性。一旦設為不可配置就不能再改回。為 false 時不能刪除、不能改特性,但仍可修改屬性值;非嚴格模式靜默忽略,嚴格模式拋出異常。 |
| [[Enumerable]] | enumerable | 數據屬性/訪問器屬性 | true | 能否透過 for-in 枚舉 |
| [[Writable]] | writable | 數據屬性 | true | 能否修改屬性值。為 false 時非嚴格模式靜默忽略,嚴格模式拋出異常 |
| [[Value]] | value | 數據屬性 | undefined | 屬性值 |
| [[Get]] | get | 訪問器屬性 | undefined | 讀取屬性時呼叫的函數,無參數呼叫並以回傳值作為屬性值 |
| [[Set]] | set | 訪問器屬性 | undefined | 寫入屬性時呼叫的函數,傳入值作為參數 |
說明:訪問器屬性不一定同時有 get 與 set:沒有 get 的屬性不能讀(回傳 undefined,嚴格模式拋錯),沒有 set 的屬性不能寫。另外注意區分「物件內部屬性」與「物件屬性的特性」。
D、屬性定義方法
最常見的定義方式就是直接賦值(obj.name = 'linjisong'),此時內部特性皆為預設值。如果想定義一個不可修改的屬性,ES5 提供了幾個方法:
// 建立一個包含預設屬性 job 的物件(可修改、刪除、枚舉)
var person = {job: 'it'};
// 添加一個不能被修改、刪除的 name 屬性
Object.defineProperty(person, 'name', {
value: 'linjisong',
enumerable: true
});
// 定義多個屬性(數據屬性 year 與訪問器屬性 age)
Object.defineProperties(person, {
year: {
value: 2012,
configurable: true,
writable: true
},
age: {
get: function(){
return this.year - 1983;
}
}
});
var job = Object.getOwnPropertyDescriptor(person, 'job');
console.info(job.configurable);// true,直接添加屬性時預設為 true
var name = Object.getOwnPropertyDescriptor(person, 'name');
console.info(name.configurable);// false,使用屬性定義方法時預設為 false
console.info(person.name); // linjisong
person.name = 'oulinhai'; // 不能修改,值不變(嚴格模式下拋出異常)
console.info(person.name); // linjisong
person.year = 2015;
console.info(person.year); // 2015
console.info(person.age); // 32,修改 year 的同時 age 也跟著變了
方法摘要:
註:這些方法能設定或取得的特性與屬性類型有關,例如數據屬性只能設定 [[Configurable]]、[[Enumerable]]、[[Writable]]、[[Value]]。
ES5 定義了三種依次升高的保護級別:
| 保護級別 | 描述 | 操作方法 | 判斷方法 |
|---|---|---|---|
| 不可擴展 | 不能添加新屬性和方法,但可修改既有成員 | preventExtensions() | isExtensible():不能擴展時回傳 false |
| 密封 | 不可擴展,且既有成員的 [[Configurable]] 設為 false,不能刪除屬性,但可修改屬性值 | seal() | isSealed():被密封時回傳 true |
| 凍結 | 密封,且 [[Writable]] 設為 false;但若定義了 [[Set]],訪問器屬性仍可寫 | freeze() | isFrozen():被凍結時回傳 true |
註:一旦定義成防篡改物件,就無法撤銷。
create() 是個很有意思的方法,規範對其行為的描述是:
① 如果 prototype 不是 Null 或 Object,拋出 TypeError 異常 ② var obj = new Object() ③ 設置 obj 的內部屬性 [[Prototype]] 為 prototype ④ 如果 descriptors 存在且不為 undefined,使用 Object.defineProperties(obj, descriptors) 添加屬性 ⑤ 回傳 obj
由於一般物件的 [[Prototype]] 無法直接存取,可以用函數模擬實作:
(function(){
function Base(){};
Object.create = function(prototype, descriptors){
var typeVal = typeof prototype;
if(typeVal !== null && typeVal !== 'object' && typeVal !== 'function'){
throw new TypeError('類型錯誤,請檢查第一個參數的類型');
}
Base.prototype = prototype;
var result = new Base();
if(descriptors){
Object.defineProperties(result, descriptors);
}
return result;
};
})();
測試一下:
try{
var one = Object.create(1);// 異常
}catch(e){
console.info(e);// TypeError
}
var base = {
name: 'linjisong',
getName: function(){
return this.name;
}
};
var two = Object.create(base);
console.info(two.name); // linjisong
console.info(two.getName()); // linjisong
var three = Object.create(base, {
name: {value: 'oulinhai'},
age: {value: 23}
});
console.info(three.getName()); // oulinhai
console.info(three.age); // 23
這裡其實已經完成了一個簡單的繼承,正好帶出下一個主題。
每個物件都有一個原型物件,而原型物件本身也是物件,也有自己的原型,這樣就形成了一條原型鏈直至 null。物件的內部屬性 [[Prototype]] 指向的就是原型物件,而 Object.prototype 的原型為 null。
存取物件的屬性(方法)時,引擎先查找物件本身;沒有則查找原型;仍沒有就繼續往原型的原型找,直到最後一個原型物件。
注意區分:屬性查找沿著原型鏈,標識符查找沿著作用域鏈,但兩者都是逐級向上查找的過程。
var obj = {};
console.info(obj.__proto__ === Object.getPrototypeOf(obj)); // true
console.info(obj.__proto__ === Object.prototype); // true
每個函數都有一個 prototype 屬性,是在函數定義過程中添加的,它指向的物件就是所有以該函數建立的實例的原型物件:
var fn = function(){};
console.info(typeof fn.prototype); // object,一旦定義函數就會添加 prototype 屬性
var obj1 = new fn();
console.info(fn.prototype === Object.getPrototypeOf(obj1)); // true
var obj2 = new fn();
console.info(fn.prototype === Object.getPrototypeOf(obj2)); // true
console.info(Object.getPrototypeOf(fn) === Function.prototype); // true
當然 fn 本身也是物件,也有自己的原型,也就是 Function 的 prototype 屬性(fn.__proto__ === Function.prototype)。
每個物件都可以存取 constructor 屬性,指向建立它的函數。實際上 constructor 只不過是構造函數原型物件上的一個屬性:
var fn = function fn(){};
var obj1 = new fn();
console.info(fn.constructor); // Function()
console.info(fn.prototype.constructor); // fn(),函數原型物件的 constructor 指向函數本身
console.info(obj1.hasOwnProperty('constructor')); // false,實例本身沒有 constructor
console.info(fn.prototype.constructor === obj1.constructor); // true
最後一點:函數的原型物件具有動態性,即使先建立實例、後修改原型,實例依然能存取到該變更:
var fn = function fn(){};
var obj = new fn();
console.info(obj.name); // undefined
fn.prototype.name = 'linjisong';
console.info(obj.name); // linjisong
| 模式 | 說明 |
|---|---|
傳統方式var person = new Object(); person.name = 'linjisong'; | 容易產生大量重複程式碼 |
物件字面值var person = { name: 'linjisong', job: 'it' }; | 簡潔明瞭,特別適合建立作為函數實參的物件 |
| 工廠模式 用函數封裝 new Object() 並回傳 | ① 有效解決重複程式碼問題 ② 但無法判定物件的類型 |
| 構造函數模式 屬性與方法都寫在 this 上 | ① 能解決重複程式碼,也能判定類型 ② 但每個實例都有一份屬性與方法的複本 ③ 方法每個實例各存一份是沒有必要的 |
| 原型模式 把成員掛在 prototype 上 | ① 解決了方法多份複本的問題 ② 但屬性也被共享,引用型別屬性會互相影響 ③ 且無法接受參數 |
| 組合構造原型模式 | 屬性用構造函數建立(每個實例一份),方法用原型共享(所有實例一份)。目前使用最廣泛 |
| 動態原型模式 | 在不習慣把構造函數與原型分開時使用,於構造函數內判斷原型方法是否存在再補上;判斷時可只看其中一個屬性 |
| 寄生構造函數模式 | 工廠模式不用 new,寄生構造模式用 new;構造函數模式不回傳,寄生構造模式回傳物件。不能用 instanceof 判斷類型 |
| 穩妥構造函數模式 | 不使用 this 與 new,類似寄生構造模式,但只能透過提供的方法存取成員。同樣不能用 instanceof 判斷類型 |
使用 new 呼叫構造函數的內部步驟是:(1)建立一個新物件;(2)將構造函數的作用域賦給新物件(this 指向新物件);(3)執行構造函數中的程式碼;(4)回傳新物件。
原型模式的共享問題可以用一個例子說明:
function Angle(){};
Angle.prototype.coordinate = [0, 0];
var a1 = new Angle();
var a2 = new Angle();
a1.coordinate[0] = 1;
console.info(a2.coordinate);// [1,0],修改 a1 會導致 a2 變更
ECMAScript 沒有介面繼承,只有實現繼承,主要透過原型鏈完成。
| 繼承方式 | 說明 |
|---|---|
原型鏈ColorSquare.prototype = new Square(); | ① 透過修改子類型建立函數的原型實現繼承 ② 為子類型添加新方法時,必須在替換原型之後,且不能再用物件字面值修改子類型原型 ③ 可用 instance instanceof fn 或 fn.prototype.isPrototype(instance) 判斷關係④ 建立子物件時無法傳遞參數 ⑤ 父類的引用型別屬性會被所有子類型實例共享,產生問題 |
借用構造函數Square.call(this); | ① 可在 call 時傳遞參數 ② 不存在引用型別共享問題 ③ 缺點是子類無法存取父類原型中定義的方法 |
| 組合繼承 原型鏈 + 借用構造函數 | ① 又稱偽經典繼承 ② 用原型鏈繼承原型屬性與方法,用借用構造函數繼承實例屬性 ③ 融合了兩者的優點,最常用 ④ 缺點是需要呼叫兩次父類構造函數 |
| 原型式繼承 用 create(o) 建立子物件 | ① 本質就是模擬 ES5 的 create 函數 ② ES5 的 create 還可接受屬性描述參數 ③ 需先有一個物件,再直接建立子物件——前者是構造函數繼承,後者是物件實例繼承 ④ 同樣有引用型別屬性共享問題 |
| 寄生式繼承 在 create() 結果上增補 | ① create 函數並非必需,任何回傳新物件的函數都可以 ② 仍有引用型別共享問題 ③ 可視為把物件繼承包裝成構造函數 |
| 寄生組合式繼承 | ① 只呼叫一次父類構造函數,避免在子類型原型上建立不必要的屬性 ② 能保證原型鏈不變,可正常使用 instanceof 與 isPrototypeOf() |
幾個關鍵程式碼:
// 原型鏈繼承
function Square(){
this.width = 10; // 邊長
this.coordinate = [0,0]; // 左上角頂點坐標
}
Square.prototype.getArea = function(){
return this.width * this.width;
};
function ColorSquare(){
this.color = 'red';
}
ColorSquare.prototype = new Square();
ColorSquare.prototype.getColor = function(){
return this.color;
};
// 引用型別共享問題
var cs2 = new ColorSquare();
console.info(cs2.coordinate); // [0,0]
cs.coordinate[1] = 1;
console.info(cs2.coordinate); // [0,1],修改 cs 會導致 cs2 也變
// 組合繼承:構造函數被呼叫兩次
function ColorSquare(){
Square.call(this); // 第二次呼叫父類構造函數
this.color = 'red';
}
ColorSquare.prototype = new Square(); // 第一次呼叫
// 寄生組合式繼承:只呼叫一次
function create(o){
var fn = function(){};
fn.prototype = o;
return new fn();
}
function inherit(sub, sup){
var prototype = create(sup.prototype);
prototype.constructor = sub;
sub.prototype = prototype;
}
function Square(){
this.width = 10;
this.coordinate = [0,0];
}
Square.prototype.getArea = function(){
return this.width * this.width;
};
function ColorSquare(){
Square.call(this);
this.color = 'red';
}
inherit(ColorSquare, Square);
ColorSquare.prototype.getColor = function(){
return this.color;
};
var cs = new ColorSquare();
console.info(cs.width); // 10
console.info(cs.getArea()); // 100
console.info(cs.color); // red
console.info(cs.getColor()); // red
var cs2 = new ColorSquare();
console.info(cs2.coordinate); // [0,0]
cs.coordinate[1] = 1;
console.info(cs2.coordinate); // [0,0],互不影響
實務結論:物件建立首選字面值與組合構造原型模式;繼承則首選寄生組合式,它兼顧了「只呼叫一次父類構造函數」與「保持原型鏈完整」這兩個關鍵點。