摘要：通過(guò)多種方式來(lái)加強(qiáng)對(duì)象的使用，通過(guò)簡(jiǎn)單的語(yǔ)法擴(kuò)展，提供更多操作對(duì)象及與對(duì)象交互的方法。增強(qiáng)對(duì)象原型改變對(duì)象的原型正常情況下，無(wú)論是通過(guò)構(gòu)造函數(shù)還是方法創(chuàng)建對(duì)象，其原型是在被創(chuàng)建時(shí)指定的。引用相當(dāng)于指向?qū)ο笤偷闹羔?/p>

ES6通過(guò)多種方式來(lái)加強(qiáng)對(duì)象的使用，通過(guò)簡(jiǎn)單的語(yǔ)法擴(kuò)展，提供更多操作對(duì)象及與對(duì)象交互的方法。

ES5中初始化屬性值的方式：

function createPerson(name, age) {
    return {
        name: name,
        age: age
    };
}

這段代碼中的createPerson()函數(shù)創(chuàng)建的對(duì)象，其屬性名與函數(shù)的參數(shù)相同，在返回的結(jié)果中，name和age分別重復(fù)了兩遍，只是其中一個(gè)是對(duì)象屬性名，另一個(gè)是為屬性賦值的變量。

ES6中可以簡(jiǎn)單地只寫(xiě)屬性名即可：

function createPerson(name, age) {
    return {
        name,
        age
    };
}

當(dāng)對(duì)象字面量里只有一個(gè)屬性的名稱時(shí)，JavaScript引擎會(huì)在可訪問(wèn)作用域中查找同名變量；如果找到，則該變量的值被賦給對(duì)象字面量的同名屬性。

ES5中定義對(duì)象方法：

var person = {
    name: "Nicholas",
    sayName: function() {
        console.log(this.name);
    }
};

ES6中簡(jiǎn)寫(xiě)后的對(duì)象方法：

var person = {
    name: "Nicholas",
    sayName() {
        console.log(this.name);
    }
};

二者唯一的區(qū)別是，簡(jiǎn)寫(xiě)方法可以使用super關(guān)鍵字（稍后會(huì)討論）。

ES5中，如果想要通過(guò)計(jì)算得到屬性名，就需要使用方括號(hào)代替點(diǎn)記法，請(qǐng)看：

var person = {};
    lastName = "last name";
    
person["first name"] = "Nicholas";
person[lastName] = "Zakas";

console.log(person["first name"]);   // "Nicholas"
console.log(person[lastName]);   // "Zakas"

ES5在對(duì)象字面量中，也可以直接使用字符串字面量作為屬性名：

var person = {
    "first name": "Nicholas"
};

console.log(person["first name"]);  // "Nicholas"

這種模式適用于屬性名提前已知或可被字符串字面量表示的情況。然而，如果屬性名"first name"被包含在一個(gè)變量中（就像之前的示例中的那樣），或者需要通過(guò)計(jì)算才能得到該變量的值，那么ES5中是無(wú)法為一個(gè)對(duì)象字面量定義該屬性的。

而在ES6中，可在對(duì)象字面量中使用可計(jì)算屬性名，請(qǐng)看：

let lastName = "last name";

let person = {
    "first name": "Nicholas",
    [lastName]: "Zakas"
};

console.log(person["first name"]);  // "Nicholas"
console.log(person[lastName]);   // "Zakas"

在對(duì)象字面量中使用方括號(hào)表示該屬性名是可計(jì)算的，它的內(nèi)容將被求值并最終轉(zhuǎn)化為一個(gè)字符串，因而同樣可以使用表達(dá)式作為屬性的可計(jì)算名稱，例如：

var suffix = " name";

var person = {
    ["first" + suffix]: "Nicholas",
    ["last" + suffix]: "Zakas"
};

console.log(person["first name"]);  // "Nicholas"
console.log(person["last name"]);   // "Zakas"

當(dāng)你想在JavaScript中比較兩個(gè)值時(shí)，可能習(xí)慣于使用相等運(yùn)算符（==）或全等運(yùn)算符（===），許多開(kāi)發(fā)者更喜歡后者，從而避免在比較時(shí)觸發(fā)強(qiáng)制類(lèi)型轉(zhuǎn)換的行為。但即使全等運(yùn)算符也不完全準(zhǔn)確，比如+0和-0在JavaScript引擎中被表示為兩個(gè)完全不同的實(shí)體，而如果使用全等運(yùn)算符===對(duì)兩者進(jìn)行比較，得到的結(jié)果是兩者相等；同樣，NaN===NaN的返回值為false，需要使用isNaN()方法才可以正確檢測(cè)NaN。

ES6引入了Object.is()方法來(lái)彌補(bǔ)全等運(yùn)算符的不準(zhǔn)確運(yùn)算。請(qǐng)看示例：

console.log(+0 == -0);   // true
console.log(+0 === -0);  // true
console.log(Object.is(+0, -0));  // false

console.log(NaN == NaN);  // false
console.log(NaN === NaN);  // false
console.log(Object.is(NaN, NaN));  // true

consolog.log(5 == 5);   // true
consolog.log(5 == "5");   // true
consolog.log(5 === 5);   // true
consolog.log(5 === "5");   // false
console.log(Object.is(5, 5));   // true
console.log(Object.is(5, "5"));   // false

對(duì)于Object.is()方法來(lái)說(shuō)，其運(yùn)行結(jié)果在大部分情況下與===運(yùn)算符相同，唯一的區(qū)別在于+0和-0被識(shí)別為不相等并且NaN與NaN等價(jià)。但是你大可不必拋棄等號(hào)運(yùn)算符，是否選擇使用Object.is()方法而不是===取決于那些特殊情況如何影響代碼。

混合（Mixin）是JavaScript種實(shí)現(xiàn)對(duì)象組合最流行的一種模式。在一個(gè)mixin方法中，一個(gè)對(duì)象接收來(lái)自另一個(gè)對(duì)象的屬性和方法，許多JavaScript庫(kù)中都有類(lèi)似minxin方法：

function mixin(receiver, supplier) {
    Object.keys(supplier).forEach(function(key) {
        receiver[key] = supplier[key];
    });
    return receiver;
}

mixin()函數(shù)遍歷supplier的自有屬性并復(fù)制到receiver中（復(fù)制行為是淺復(fù)制，當(dāng)屬性值為對(duì)象時(shí)只復(fù)制對(duì)象的引用）。這樣一來(lái)，receiver不通過(guò)繼承就可以獲得新屬性，請(qǐng)參考這段代碼：

function EventTarget() { ... }
EventTarget.prototype = {
    constructor: EventTarget,
    emit: function() { ... },
    on: function() { ... }
};

var myObject = {};
mixin(myObject, EventTarget.prototype);

myObject.emit("somethingChanged");

這種混合模式非常流行，因而ES6添加了Object.assign()方法來(lái)實(shí)現(xiàn)相同的功能：

Object.assign(myObject, EventTarget.prototype);

Object.assign()方法接受一個(gè)接收對(duì)象和任意數(shù)量的源對(duì)象，最終返回接收對(duì)象。如果多個(gè)源對(duì)象具有相同屬性，則排位靠后的會(huì)覆蓋排位靠前的。

需要注意的是，Object.assign()方法不能將提供者的訪問(wèn)器屬性復(fù)制到接收對(duì)象中。由于Object.assign()方法執(zhí)行了賦值操作，因此提供者的訪問(wèn)器屬性最終會(huì)轉(zhuǎn)變?yōu)榻邮諏?duì)象中的一個(gè)數(shù)據(jù)屬性，請(qǐng)看示例：

var receiver = {},
    supplier = {
        get name() {
            return "file.js";
        }
    };
    
Object.assign(receiver, supplier);

var descriptor = Object.getOwnPropertyDescriptor(receiver, "name");

console.log(descriptor.value);   // "file.js"
console.log(descriptor.get);     // undefined

在這段代碼中，supplier有一個(gè)名為name的訪問(wèn)器屬性。當(dāng)調(diào)用Object.assign()方法時(shí)返回字符串"file.js"，因此receiver接收這個(gè)字符串后將其存為數(shù)據(jù)屬性receiver.name。

正常情況下，無(wú)論是通過(guò)構(gòu)造函數(shù)還是Object.create()方法創(chuàng)建對(duì)象，其原型是在被創(chuàng)建時(shí)指定的。對(duì)象原型在實(shí)例化之后保持不變，直到ES5都是JavaScript編程最重要的設(shè)定之一，雖然在ES5中添加了Object.getPrototypeOf()方法來(lái)返回任意指定對(duì)象的原型，但仍缺少對(duì)象在實(shí)例化后改變?cè)偷臉?biāo)準(zhǔn)方法。

所以，在ES6中添加了Object.setPrototypeOf()方法來(lái)改變這一現(xiàn)狀：

let person = {
    getGreeting() {
        return "Hello";
    }
};

let dog = {
    getGreeting() {
        return "Woof";
    }
};

// 以person對(duì)象為原型
let friend = Object.create(person);
console.log(friend.getGreeting());     // "Hello"
console.log(Object.getPrototypeOf(friend) === person);   // true

// 將原型設(shè)置為dog
console.log(friend.getGreeting());   // "Woof"
console.log(Object.getPrototypeOf(friend) === dog);   // true

這段代碼定義了兩個(gè)基對(duì)象：person和dog。二者多有getGreeting()方法。friend對(duì)象先繼承person對(duì)象，調(diào)用getGreeting()方法輸出"Hello"；當(dāng)原型被變更為dog對(duì)象時(shí)，原先與person對(duì)象的關(guān)聯(lián)被解除，調(diào)用person.getGreeting()方法時(shí)輸出的內(nèi)容就變?yōu)榱?Woof"。

對(duì)象原型的真實(shí)值被存儲(chǔ)在內(nèi)部專用屬性[[Prototype]]中，調(diào)用Object.getPrototypeOf()方法返回存儲(chǔ)在其中的值，調(diào)用Object.setPrototypeOf()方法改變其中的值。然而，這不是操作[[Prototype]]值的唯一方法。

ES6引入了super引用的特性，使用它可以更便捷地訪問(wèn)對(duì)象原型。舉個(gè)例子，如果你想重寫(xiě)對(duì)象實(shí)例方法，又需要調(diào)用與它同名的原型方法，先看看ES5中的實(shí)現(xiàn)：

let person = {
    getGreeting() {
        return "Hello";
    }
};

let dog = {
    getGreeting() {
        return "Woof";
    }
};

let friend = {
    getGreeting() {
        return Object.getPrototypeOf(this).getGreeting.call(this) + ", hi!";
    }
};

// 將原型設(shè)置為`person`
Object.setPrototypeOf(friend, person);
console.log(friend.getGreeting());   // "Hello, hi!"
console.log(Object.getPrototypeOf(friend) === person);   // true

// 將原型設(shè)置為`dog`
Object.setPrototypeOf(friend, dog);
console.log(friend.getGreeting());   // "Woof, hi!"
console.log(Object.getPrototypeOf(friend) === dog);   // true

在這個(gè)示例中，friend對(duì)象的getGreeting()方法調(diào)用了同名的原型方法。Object.getPrototypeOf()方法可以確保調(diào)用正確的原型，并向輸出字符串疊加另一個(gè)字符串；后面的.call(this)可以確保正確設(shè)置原型方法中的this值。

要準(zhǔn)確記得如何使用Object.getPrototypeOf()方法和.call(this)方法來(lái)調(diào)用原型上的方法實(shí)在有些復(fù)雜，所以ES6引入了super關(guān)鍵字。super引用相當(dāng)于指向?qū)ο笤偷闹羔槪?/p>

let friend = {
    getGreeting() {
        // return Object.getPrototypeOf(this).getGreeting.call(this) + ", hi!";
        return sper.getGreeting() + ", hi!";
    }
};