JS的物件原型

gzhjj發表於2018-05-10
JS物件原型

1.物件

1.1 語法

物件可以通過兩種形式定義：宣告(文字)形式和構造形式。
物件的文字語法：

var myObj = {
    key : value
    //...
};

物件的構造語法：

var myObj = new Object();
myObj.key = value;

1.2 型別

物件是JavaScript的基礎。在JavaScript中一共有六種主要型別（術語是“語言型別”）：

  • string
  • number
  • boolean
  • null
  • undefined
  • object

函式是物件的一個子型別(從技術角度來說就是“可呼叫的物件”)。
陣列也是物件的一種型別，具備一些額外的行為。

JavaScript中還有一些物件子型別，通常被稱為內建物件。

  • String
  • Number
  • Boolean
  • Object
  • Function
  • Array
  • Date
  • RegExp
  • Error

在JavaScript中，它們實際上只是一些內建函式，這些內建函式可以當作建構函式來使用。
相關閱讀：JavaScript 參考手冊

var strPrimitive = "I am a string";
typeof strPrimitive;//"string"
strPrimitive instanceof String;//false

原始值"I am a string"並不是一個物件，它只是一個字面量，並且是一個不可變的值。如果要在這個字面量上執行一些操作，比如獲取長度、訪問其中某個字元等，那需要將其轉換為String物件。
幸好，在必要時語言會自動把字串字面量轉換成一個String物件，也就是說你並不需要顯式建立一個物件。

var strPrimitive = "I am a string";
console.log(strPrimitive.length);//13
console.log(strPrimitive.charAt(3));//"m"

我們可以直接在字串字面量上訪問屬性或者方法，因為引擎自動把字面量轉換成String物件，所以可以訪問屬性和方法。
對於數值字面量和布林字面量也是如此。
null和undefined沒有對應的構造形式，它們只有文字形式。
Date只有構造，沒有文字形式。
對於Object、Array、Function和RegExp來說，無論使用文字形式還是構造形式，它們都是物件，不是字面量。
Error物件很少在程式碼中顯式建立，一般是在丟擲異常時被自動建立。

1.3 內容

物件的內容是由一些儲存在特定命名位置的值組成的，我們稱之為屬性。
在引擎內部，這些值的儲存方式是多種多樣的，一般並不會存在物件容器內部。
儲存在物件容器內部的是這些屬性的名稱，它們就像指標(從技術角度來說就是引用)一樣，指向這些值真正的儲存位置。

var myObject = {
    a : 2
};

myObject.a;//2
myObject["a"];//2

如果要訪問myObject中a位置上的值，我們需要使用.操作符或者[]操作符。
.a語法通常被稱為“屬性訪問”， ["a"]語法通常被稱為“鍵訪問”。
.操作符要求屬性名滿足識別符號的命名規範，而[".."]語法可以接受任意UTF-8/Unicode字串作為屬性名。
在物件中，屬性名永遠都是字串。如果你使用string(字面量)以外的其他值作為屬性名，那它首先會被轉換為一個字串。

ES6增加了可計算屬性名，可以在文字形式中使用[]包裹一個表示式來當作屬性名。

var prefix = "foo";

var myObject = {
    [prefix + "bar"] : "hello",
    [prefix + "baz"] : "world"
};

myObject["foobar"];//hello
myObject["foobaz"];//world

陣列支援[]訪問形式。

var myArray = ["foo",42,"bar"];

myArray.length;//3
myArray[0];//"foo"
myArray[2];//"bar"

陣列也是物件，所以雖然每個下標都是整數，你仍然可以給陣列新增屬性：

var myArray = ["foo",42,"bar"];

myArray.baz = "baz";
myArray.length;//3
myArray.baz;//"baz"

你可以把陣列當作一個普通的鍵/值物件來使用，並且不新增任何數值索引。
但最好只用物件來儲存鍵/值對，只用陣列來儲存數值下標/值對。
注意：如果你試圖向陣列新增一個屬性，但是屬性名“看起來”像一個數字，那它會變成一個數值下標。

var myArray = ["foo",42,"bar"];

myArray["3"] = "baz";
myArray.length;//4
myArray[3];//"baz"

複製物件

對於JSON安全的物件來說，有一種巧妙的複製方法：var newObj = JSON.parse(JSON.stringify(someObj))
ES6定義了Object.assign(..)方法來實現淺複製。

屬性描述符

從ES5開始，所有的屬性都具備了屬性描述符。
在建立普通屬性時屬性描述符會使用預設值，我們也可以使用Object.defineProperty(..)來新增一個新屬性或者修改一個已有屬性並對特性進行設定。

var myObject = {}
Object.defineProperty(myObject,"a",{
    value:2,
    writable:true,
    configurable:true,
    enumerable:true
});
myObject.a;//2
//writable：是否可以修改屬性的值
//configurable：是否可以配置
//enumerable：屬性的值是否可以被列舉

遍歷

var myArray = [1,2,3];
for(var i = 0; i < myArray.length; i++){
    console.log(myArray[i]);
}//1 2 3

這實際上並不是在遍歷值，而是遍歷下標來指向值。
ES5中增加了一些陣列的輔助迭代器，包括forEach(..)、every(..)和some(..)。

ES6增加了一種用來遍歷陣列的for..of迴圈語法。

var myArray = [1,2,3];
for(var v of myArray){
    console.log(v);
}
//1
//2
//3

for..of迴圈首先會向被訪問物件請求一個迭代器物件，然後通過呼叫迭代器物件的next()方法來遍歷所有返回值。

var myArray = [1,2,3];
var it = myArray[Symbol.iterator]();

it.next();//{value:1,done:false}
it.next();//{value:2,done:false}
it.next();//{value:3,done:false}
it.next();//{done:true}

我們使用ES6中的符號Symbol.iterator來獲取物件的iterator內部屬性。
和陣列不同，普通的物件沒有內建的iterator，所以無法自動完成for..of遍歷。

2.原型

2.1 [[Prototype]]

JavaScript中的物件有一個特殊的[[Prototype]]內建屬性，其實就是對於其他物件的引用。幾乎所有的物件在建立時[[Prototype]]屬性都會被賦予一個非空的值。

var myObject = {
    a : 2
};

myObject.a;//2

當我們試圖引用物件的屬性時會觸發[[Get]]操作，比如myObject.a。對於預設的[[Get]]操作來說，第一步是檢查物件本身是否有這個屬性，如果有的話就使用它。但是如果a不在myObject中，就需要使用物件的[[Prototype]]鏈了。
對於預設的[[Get]]操作來說，如果無法在物件本身找到需要的屬性，就會繼續訪問物件的[[Prototype]]鏈。

var anotherObject = {
    a : 2
};

var myObject = Object.create(anotherObject);

myObject.a;//2

現在myObject物件的[[Prototype]]鏈關聯到了anotherObject。顯然myObject.a並不存在，但是儘管如此，屬性訪問仍然成功地找到了值2。但是，如果anotherObject中也找不到a並且[[Prototype]]鏈不為空的話，就會繼續查詢下去。

Object.prototype

所有普通的[[Prototype]]鏈最終都會指向內建的Object.prototype。
所有的“普通”物件都把[[Prototype]]鏈的頂端設定為這個Object.prototype物件，所以它包含JavaScript中許多通用的功能。

屬性設定和遮蔽

myObject.foo = "bar"
如果myObject物件中包含名為foo的普通資料訪問屬性，這條賦值語句只會修改已有的屬性值。
如果foo不是直接存在於myObject中，[[Prototype]]鏈就會被遍歷，類似[[Get]]操作。如果原型鏈上找不到foo，foo就會被直接新增到myObject上。

如果屬性名foo既出現在myObject中，也出現在myObject上的[[Prototype]]鏈上層，那麼就會發生遮蔽。myObject中包含的foo屬性會遮蔽原型鏈上層的所有屬性，因為myObject.foo總是會選擇原型鏈中最底層的foo屬性。

遮蔽比我們想象中更加複雜。
通常來說，應當儘量避免使用遮蔽。

var anotherObject = {
    a : 2
};

var myObject = Object.create(anotherObject);

anotherObject.a;//2
myObject.a;//2

anotherObject.hasOwnProperty("a");//true
myObject.hasOwnProperty("a");//false

myObject.a++;//隱式遮蔽！

anotherObject.a;//2
myObject.a;//3

myObject.hasOwnProperty("a");//true

2.2 “類”

所有的函式預設都會擁有一個名為prototype的公有並且不可列舉的屬性，它會指向另一個物件。這個物件通常被稱為Foo的原型。

Foo.prototype預設有一個公有並且不可列舉的屬性.constructor，這個屬性引用的是物件關聯的函式。

在JavaScript中對於“建構函式”最準確的解釋是，所有帶new的函式呼叫。
函式不是建構函式，但是當且僅當使用new時，函式呼叫會變成“建構函式呼叫”。

2.3 (原型)繼承

function Foo(name){
    this.name = name;
}

Foo.prototype.myName = function(){
    return this.name;
};

function Bar(name,label){
    Foo.call(this,name);
    this.label = label;
}

//我們建立了一個新的Bar.prototype物件並關聯到Foo.prototype
Bar.prototype = Object.create(Foo.prototype);

Bar.prototype.myLabel = function(){
    return this.label;
};

var a = new Bar("a","obj a");

a.myName();//"a"
a.myLabel();//"obj a"

這段程式碼的核心部分是Bar.prototype = Object.create(Foo.prototype)。呼叫Object.create(..)會憑空建立一個“新”物件並把新物件內部的[[Prototype]]關聯到你指定的物件。即建立一個新的Bar.prototype物件並把它關聯到Foo.prototype。

在ES6之前，我們通過設定._proto_屬性來修改物件的[[Prototype]]關聯，但是這個方法並不是標準並且無法相容所有瀏覽器。
ES6新增了輔助函式Object.setPrototypeOf(..)，可以用標準並且可靠的方法來修改關聯。

2.4 物件關聯

[[Prototype]]機制是存在於物件中的一個內部連結，它會引用其他物件。
這個連結的作用是：如果在物件上沒有找到需要的屬性或者方法引用，引擎就會繼續在[[Prototype]]關聯的物件上進行查詢。如果在後者中也沒有找到需要的引用就會繼續查詢它的[[Prototype]]，以此類推，這一系列的連結被稱為“原型鏈”。

建立關聯

var foo = {
    something : function(){
        console.log("Tell me something good...");
    }
};

var bar = Object.create(foo);

bar.something();//Tell me something good...

Object.create(..)會建立一個新物件(bar)並把它關聯到我們指定的物件(foo)，這樣我們就可以充分發揮[[Prototype]]機制的威力(委託)並且避免不必要的麻煩(比如使用new的建構函式呼叫會生成.prototype和.constructor引用)。

3.行為委託

Task = {
    setID : function(ID){this.id=ID;},
outputID : function(){console.log(this.id);}
};

//讓XYZ委託給Task
XYZ = Object.create(Task);

XYZ.prepareTask = function(ID,Label){
    this.setID(ID);
    this.label = Label;
};

XYZ.outputTaskDetails = function(){
    this.outputID();
    console.log(this.label);
};

XYZ通過Object.create(..)建立，它的[[Prototype]]委託了Task物件。
這種編碼風格稱為“物件關聯”(OLOO)。

比較思維模型

模仿類的行為

function Foo(who){
    this.me = who;
}

Foo.prototype.identify = function(){
    return "I am " + this.me;
};

function Bar(who){
    Foo.call(this,who);
}

Bar.prototype = Object.create(Foo.prototype);

Bar.prototype.speak = function(){
    alert("Hello, " + this.identify() + ".");
};

var b1 = new Bar("b1");
var b2 = new Bar("b2");

b1.speak();
b2.speak();

物件關聯風格

Foo = {
    init: function(who){
        this.me = who
    },
    identify: function(){
        return "I am " + this.me;
    }
};

Bar = Object.create(Foo);

Bar.speak = function(){
    alert("Hello, " + this.identify() + ".");
};

var b1 = Object.create(Bar);
b1.init("b1");
var b2 = Object.create(Bar);
b2.init("b2");

b1.speak();
b2.speak();

參考資料：《你不知道的JavaScript》(上卷) 第二部分 this和物件原型

相關文章