在 JavaScript 中,除了五種原始類型(數字、字符串、布爾值、null、undefined)之外,一切都是對象。所以,對象這塊不把學明白,後面的知識很難往下走。

對象是一種復合值,它把多個值(原始值或其他對象)聚合在一起,並通過屬性名訪問這些值。屬性名可以是包含空字符串在內的任意字符串。
JavaScript 對象也可以理解為一種數據結構,正如我們常聽到的「散列(hash)」「散列表(hashtable)」「字典(dictionary)」「關聯數組(associative array)」。
對象可以分為三類:
①內置對象,例如數組、函數、日期等;
②宿主對象,即 JavaScript 解釋器所嵌入的宿主環境(比如瀏覽器)定義的,例如 HTMLElement;
③自定義對象,即程序員用代碼定義的。
對象的屬性則分兩類:
①自有屬性(own property):直接在對象中定義的屬性;
②繼承屬性(inherited property):在對象的原型對象中定義的屬性。
面試前端崗位時,這是一個高頻基礎題:「創建 JavaScript 對象的方法有哪些?」網上常說有兩種,但從書籍來看實際上有三種。
由若干名/值對組成的映射表,名值對之間用逗號分隔,用花括號括起來。屬性名可以是標識符也可以是字符串直接量,以下兩種寫法完全等價:
var obj = {x: 1, y: 2};
var obj = {'x': 1, 'y': 2};
new 運算符後跟隨一個構造函數調用,創建並初始化一個新對象:
var o = new Object(); // 空對象,等同於 {}
var a = new Array(); // 空數組,等同於 []
var d = new Date(); // 表示當前時間的 Date 對象
ECMAScript 5 定義了 Object.create() 方法,第一個參數是對象的原型,第二個可選參數用於對屬性做進一步描述。因為它是 ES5 才引入的,所以早期大家才常說「創建對象有兩種方法」。
var o1 = Object.create({x: 1, y: 2}); // o1 繼承了屬性 x 和 y
var o2 = Object.create(null); // o2 沒有原型
下面三種寫法完全等價:
var obj1 = {};
var obj2 = new Object();
var obj3 = Object.create(Object.prototype);
有人說過一句很到位的話:JavaScript 是一種基於對象(object-based)的語言,你遇到的所有東西幾乎都是對象;但它又不是真正的面向對象編程語言,因為語法中沒有 class。
沒有類,那繼承怎麼實現?答案就是原型對象。基本上每一個 JavaScript 對象(null 除外)都與另一個對象相關聯,「另一個」就是它的原型對象。每個對象都從原型對象繼承屬性,而對象的 prototype 屬性的值就是它的原型對象。
於是語言規定了:
①通過對象直接量創建的對象,原型是 Object.prototype;
②通過 new + 構造函數創建的對象,原型是構造函數 prototype 屬性的值,所以 new Object() 的原型也是 Object.prototype;
③Object.create() 的第一個參數就是新對象的原型。
可以通過點(.)或方括號([])運算符獲取和設置屬性值。點右側必須是以屬性名命名的標識符;方括號內必須是一個字符串表達式。
var obj = {x: 1, y: 2};
obj.x = 5;
obj['y'] = 6;
查詢對象 obj 的屬性 x 時,引擎會先查 obj 的自有屬性,沒有則查 obj 的原型,再沒有則繼續查原型的原型,直到找到 x 或到達原型為 null 的對象為止。這一層層原型構成的鏈條,就是我們常說的原型鏈,這種繼承方式被稱為原型式繼承(prototypal inheritance)。
需要注意的是:查詢時會沿原型鏈向上查找,但設置時只會修改自有屬性(若對象本身沒有該屬性,則添加並賦值),不會影響原型鏈上的其他對象。
前面說的都是「數據屬性」(data property),只有一個簡單的值。而在 ECMAScript 5 中,屬性值可以用一個或兩個方法替代,這兩個方法就是 getter 和 setter,這樣的屬性被稱為「存取器屬性」(accessor property)。
查詢存取器屬性時,JavaScript 調用 getter 方法(無參數),其返回值即屬性值;設置時則調用 setter,把賦值表達式右側的值作為參數傳入。同時具備兩者則是讀/寫屬性;只有 getter 是只讀屬性(賦值不報錯但不生效);只有 setter 是只寫屬性(讀取總返回 undefined)。
var p = {
x: 1.0,
y: 2.0,
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;
},
get theta(){
return Math.atan2(this.y, this.x);
},
print: function(){
console.log('x:' + this.x + ', y:' + this.y);
}
};
注意 getter 和 setter 的定義沒有使用 function 關鍵字,而是用 get 和 set,屬性名與函數體之間也沒有冒號。而 print 屬性是一個正經的方法。另外,getter / setter 內部的 this 指向所屬對象——JavaScript 把它們當作對象的方法來調用。

如控制台輸出所示,r 和 theta 與 x、y 一樣是值屬性,print 則是方法屬性。存取器讓屬性讀寫背後可以掛上計算與校驗邏輯,使鍵值對的操作更加嚴謹。
delete 運算符可以刪除對象的屬性,操作數應是一個屬性訪問表達式。但要注意:delete 只是斷開屬性與宿主對象的聯繫,並不會去操作屬性中的屬性。
var a = {p: {x: 1}};
var b = a.p;
delete a.p;
執行後 b.x 依然是 1。由於已刪除屬性的引用仍然存在,這種不嚴謹的寫法可能造成內存洩露,銷毀對象時應遍歷屬性中的屬性依次刪除。
delete 返回 true 的情況:
①刪除成功或沒有任何副作用(比如刪除不存在的屬性);
②delete 後不是一個屬性訪問表達式。
var obj = {x: 1, get r(){return 5;}, set r(newvalue){this.x = newvalue;}};
delete obj.x; // 刪除自有屬性 x,返回 true
delete obj.x; // 刪除不存在的屬性,返回 true
delete obj.r; // 刪除存取器屬性 r,返回 true
delete obj.toString; // 繼承而來,刪不掉但無副作用,返回 true
delete 1; // 不是屬性訪問表達式,返回 true
delete 返回 false 的情況:刪除可配置性(configurable)為 false 的屬性時。
delete Object.prototype; // 返回 false,prototype 不可配置
// var 聲明的變量、function 聲明的函數都是全局對象的不可配置屬性
var x = 1;
delete this.x; // 返回 false
function f() {}
delete this.f; // 返回 false
除了名字和值,屬性還包含三種標識:可寫(writable)、可枚舉(enumerable)、可配置(configurable)。ECMAScript 3 中無法設置這些特性,所有程序創建的屬性都是可寫、可枚舉、可配置的。ES5 提供了查詢和設置這些特性的 API,對庫的開發者尤為有用:
①可以給原型對象添加方法並設為不可枚舉,讓它們更像內置方法;
②可以定義不能修改或刪除的屬性,借此「鎖定」對象。
按照「把 getter/setter 看作特性」的邏輯,可以認為屬性包含一個名字和四個特性:數據屬性的四個特性是值(value)、可寫性(writable)、可枚舉性(enumerable)、可配置性(configurable);存取器屬性則用 get、set 代替 value 和 writable。
ES5 定義了「屬性描述符」(property descriptor)對象來代表這四個特性,描述符的屬性名與它所描述的特性同名。可以通過 Object.getOwnPropertyDescriptor() 獲取:

從名字就能看出,它只能拿到自有屬性的描述符,對繼承屬性和不存在的屬性返回 undefined。
設置屬性特性則調用 Object.defineProperty(),傳入目標對象、屬性名和描述符對象:


可以看到:描述符對象不必包含全部四個特性;可寫性控制屬性值能否修改;可枚舉性控制屬性是否出現在枚舉中;可配置性控制其他特性(包括能否刪除)能否改動。
要一次修改或創建多個屬性,則使用 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 88; },
set: function(newvalue){ this.x = newvalue; },
enumerable: true, configurable: true
},
greet: {
value: function(){ console.log('hello, world'); },
writable: true, enumerable: true, configurable: true
}
});
兩者都返回修改後的對象。
值得一提的是,在 ES5 之前,多數瀏覽器(IE 除外)就已支持對象直接量中的 get / set 寫法,並提供了四個非標准的老式 API:__lookupGetter__()、__lookupSetter__() 用於查詢 getter / setter,__defineGetter__()、__defineSetter__() 用於定義。這四個方法都用雙下劃線包裹,以表明其非標准身份。

把對象看作屬性的集合,我們常常需要判斷某個屬性是否存在。有三種方法:
左側是屬性名(字符串),右側是對象。自有或繼承屬性中包含該屬性即返回 true。
先給 Object.prototype 添加一個可枚舉屬性 m 和一個不可枚舉屬性 n,再給對象 obj 定義可枚舉屬性 x 與不可枚舉屬性 y:

結論:in 運算符不區分屬性是否可枚舉,自有和繼承的都算。
只檢測自有屬性(不論是否可枚舉),對繼承屬性返回 false。

是 hasOwnProperty() 的增強版,只有「是自有屬性」且「可枚舉性為 true」時才返回 true。

比檢測更常用的是枚舉。通常使用 for/in 循環,它會遍歷對象所有可枚舉的自有屬性和繼承屬性,把屬性名賦值給循環變量。

for/in 的規則與 in 運算符並不相同,這一點容易想錯。如果不想遍歷繼承而來的屬性,可以在循環內加一層判斷:
for (prop in obj) {
if (obj.hasOwnProperty(prop)) {
console.log(prop);
}
}
此外 ES5 還定義了兩個枚舉屬性名的函數:
①Object.getOwnPropertyNames(),返回對象所有自有屬性的名稱,不論是否可枚舉;
②Object.keys(),只返回可枚舉的自有屬性名稱。

每個對象都有與之相關的原型(prototype)、類(class)和可擴展性(extensible)。
原型屬性用來繼承屬性,重要到我們常把「o 的原型屬性」直接叫做「o 的原型」。它在實例創建之初就設置好了:
①對象直接量創建的原型是 Object.prototype;
②new + 構造函數創建的原型是構造函數 prototype 屬性的值;
③Object.create() 創建的原型是第一個參數(若為 null 則原型值為 undefined;若為 undefined 則會拋出 TypeError)。
ES5 中可用 Object.getPrototypeOf() 查詢原型:

ES3 中沒有這個函數,常用 obj.constructor.prototype 間接檢測,因為每個對象都有一個 constructor 屬性指向它的構造函數。
要判斷一個對象是否是另一個對象的原型(或處於其原型鏈中),可以使用 isPrototypeOf():

還有一個非標准但被眾多瀏覽器實現的屬性 __proto__,可用於直接查詢和設置對象的原型。
類屬性是一個字符串,表示對象的類型信息。ECMAScript 3 和 5 都未提供設置方法,只有一種間接的查詢方式:默認的 toString() 方法(繼承自 Object.prototype)返回 [object class] 格式的字符串。
由於很多對象(如 Array、Date)重寫了 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);
}


從運行結果可以看出,通過三種方式創建的對象,類屬性都是 'Object'。
可擴展性表示是否可以給對象添加新屬性。所有內置對象和自定義對象默認都是可擴展的(除非被轉為不可擴展),宿主對象的可擴展性由 JavaScript 引擎定義。
ES5 提供了相關函數:
①查詢:Object.isExtensible(obj);
②設置:Object.preventExtensions(obj)。注意一旦轉為不可擴展就無法再轉回;且它只影響對象本身,給不可擴展對象的原型添加屬性,該對象仍能繼承到。
更進一步,Object.seal() 除了設置不可擴展,還把所有自有屬性設為不可配置。已封閉的對象不能解封,可用 Object.isSealed() 檢測。
最嚴格的是 Object.freeze(),它「凍結」對象:不可擴展 + 屬性不可配置 + 所有自有數據屬性變為只讀(若存取器屬性有 setter,則不受影響)。用 Object.isFrozen() 檢測。
這三個方法都返回傳入的對象,因此可以嵌套調用:
var obj = Object.seal(
Object.create(
Object.freeze({x: 1}),
{y: {value: 2, writable: true}}
)
);
對象序列化(serialization)是指將對象的狀態轉換為字符串,也可以把字符串還原為對象。ES5 提供了內置函數 JSON.stringify() 和 JSON.parse()。JSON 全稱 JavaScript Object Notation,語法與對象、數組直接量非常相近。

其中最後的 jsonObj 是 obj 的深拷貝。
JSON 語法是 JavaScript 的子集,並不能表示所有值。它支持對象、數組、字符串、有限數字、true、false 和 null。幾個注意點:
①NaN、Infinity 和 -Infinity 序列化後是 null;
②JSON.stringify() 只能序列化對象可枚舉的自有屬性;
③日期對象序列化後是 ISO 格式的字符串(參照 Date.toJSON()),但 JSON.parse() 只會保留字符串形態,不會還原為日期對象;
④函數、RegExp、Error 對象和 undefined 值無法序列化和還原。
把原型鏈、屬性描述符、this 指向這幾件事串起來看,JavaScript 的對象系統其實結構清晰,只是概念名稱容易讓人誤以為很複雜。以上就是本文的全部內容,希望對大家的學習有所幫助。