DIV CSS 佈局教程網

JavaScript 物件再深入:屬性特性、原型鏈與七種建立模式
編輯:JavaScript基礎知識     

1. 物件再認識

(1)屬性與特性

什麼是屬性(Property),什麼是特性(Attribute)?這裡不做語義學上的區分:屬性就是組成物件的一個部分(廣義上也包含方法),是我們能透過程式碼存取的具體存在;特性則是被描述主體所具備的特徵,是為了便於理解概念的抽象存在,可以透過對應屬性外化。本節所講的「屬性的特性」,就是對屬性特徵的描述,主要來自 ECMA-262 第 5 版,規範以雙中括號表示無法直接存取的內部特性。

A、屬性類型

  • 數據屬性:直接存取屬性值的屬性
  • 訪問器屬性:透過 getter/setter 方法存取屬性值的屬性
  • 內部屬性:無法透過程式碼直接存取,僅存在於規範說明中,以雙中括號表示

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 專用

說明:

  • 每個物件都有一個原型物件 [[Prototype]],一般無法直接存取,但可用 Object.getPrototypeOf(object) 取得(Firefox 中可用 __proto__)。
  • 在 Object.prototype.toString 中,內建物件會回傳包含 [[Class]] 的值 "[object class]",因此可用 Object.prototype.toString.call(value) == '[object Array]' 判斷是否為陣列。
  • 賦值時後台呼叫 [[Put]],取值時呼叫 [[Get]]。
  • 用 new 呼叫函數時後台呼叫 [[Construct]],用 call 呼叫時呼叫 [[Call]]。
  • [[HasInstance]] 判斷參數是否由該函數呼叫而建立,與 isPrototypeOf(obj) 類似。
  • 函數被執行時會建立一個 [[Scope]] 物件,可理解為前面說的活動物件;this、arguments、形式參數、內部定義的變數與函數都是它的屬性。

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 也跟著變了

方法摘要:

  • defineProperty():定義一個屬性,參數為(目標物件、屬性名、屬性描述符物件)。使用屬性定義方法時,[[Enumerable]]、[[Configurable]]、[[Writable]] 預設皆為 false。
  • defineProperties():定義一組屬性,參數為(目標物件、多個屬性描述符組成的物件)。
  • getOwnPropertyDescriptor():取得屬性特性,參數為(目標物件、屬性名),回傳包含特性的物件。

註:這些方法能設定或取得的特性與屬性類型有關,例如數據屬性只能設定 [[Configurable]]、[[Enumerable]]、[[Writable]]、[[Value]]。

(2)防篡改物件

ES5 定義了三種依次升高的保護級別:

保護級別描述操作方法判斷方法
不可擴展不能添加新屬性和方法,但可修改既有成員preventExtensions()isExtensible():不能擴展時回傳 false
密封不可擴展,且既有成員的 [[Configurable]] 設為 false,不能刪除屬性,但可修改屬性值seal()isSealed():被密封時回傳 true
凍結密封,且 [[Writable]] 設為 false;但若定義了 [[Set]],訪問器屬性仍可寫freeze()isFrozen():被凍結時回傳 true

註:一旦定義成防篡改物件,就無法撤銷。

(3)物件的其他方法

  • create(prototype[, descriptors]):建立一個具有指定原型、並可選擇性包含指定屬性的物件
  • getOwnPropertyNames(object):回傳物件所有屬性(方法)的名稱
  • getPrototypeOf(object):回傳物件的原型
  • keys(object):回傳物件「可枚舉」屬性(方法)的名稱

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

這裡其實已經完成了一個簡單的繼承,正好帶出下一個主題。

2. 原型物件

(1)原型與原型鏈

每個物件都有一個原型物件,而原型物件本身也是物件,也有自己的原型,這樣就形成了一條原型鏈直至 null。物件的內部屬性 [[Prototype]] 指向的就是原型物件,而 Object.prototype 的原型為 null。

(2)屬性查找

存取物件的屬性(方法)時,引擎先查找物件本身;沒有則查找原型;仍沒有就繼續往原型的原型找,直到最後一個原型物件。

注意區分:屬性查找沿著原型鏈,標識符查找沿著作用域鏈,但兩者都是逐級向上查找的過程。

(3)[[Prototype]] 與 prototype

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

3. 建立物件的七種模式

模式說明
傳統方式
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 變更

4. 繼承

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],互不影響

實務結論:物件建立首選字面值與組合構造原型模式;繼承則首選寄生組合式,它兼顧了「只呼叫一次父類構造函數」與「保持原型鏈完整」這兩個關鍵點。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved