1.對象 1.1 語法 對象可以通過兩種形式定義:聲明(文字)形式和構造形式。 對象的文字語法: 對象的構造語法: 1.2 類型 對象是JavaScript的基礎。在JavaScript中一共有六種主要類型(術語是“語言類型”): string number boolean null undefin ...
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和對象原型