ES6 對象加強

　　對象字面量語法擴展：

　　1, 屬性初始化語法簡寫：給一個屬性賦一個變量值，若是變量名和屬性名相同，能夠省略變量名和冒號，直接寫屬性名，js引擎在執行代碼的時候，自動查找 和屬性命名相同的變量並賦值。

let x = 1, y = 2;
let object = { 
　　x, // 屬性名是x，變量名也是x, 二者一致，能夠簡寫
　　y 
};
console.log(object.x); //output "1"

　　2, 更爲簡潔 的方法屬性定義：ES5的時候，把一個函數賦值給屬性的時候，函數必須是一個完整的函數定義

let object = {
    myFunction: function(){
        console.log("Hello World")  
    }  
}

　　可是在ES6中，能夠把:function 這一部分去掉了，寫法以下

let object = {
    myFunction(){
        console.log("Hello World")  
    }  
}

　　語法確實簡潔多了，不過要注意一個特殊狀況，只有給屬性賦值的是匿名函數的時候，纔可使用簡潔語法，若是賦值的是一個有名字的函數，那麼就不能使用匿名函數了。以下狀況就不能

let object = {
    myFunction: function hello(){
        console.log("Hello World")  
    }  
}

　　函數hello 賦值給屬性myFunction, 你可能會問，爲何要給函數取一個hello 名字，最多見的一種狀況是遞歸，本身調用本身，若是沒有名字，怎麼調用？還有就是程序debugger 的時候，有函數名字能夠直接定位， you don't know js 的做者就強烈建議書寫有名字的函數。

　　3, 計算屬性名：ES5 的時候，對象字面量中的屬性都是事先定義好的， 不能使用變量，從而在程序運行的時候動態生成屬性，但在ES6中，這種狀況改變了，對象字面量中能夠存在動態生成的屬性，不過語法就要稍微變一下了，須要把動態屬性用[] 包括起來，這樣在程序運行的時候能夠對[] 中的內容進行計算

let object = {
　　["first" + "Name"]: "Eden",
};

//extract
console.log(object["first" + "Name"]); //Output "Eden"

　　4， 對重複屬性名的處理: 在ES5 的時候，若是給一個對象賦值爲相同的屬性，它就會報錯。但在ES6 下，它不會報錯了，它會取最後一個相同屬性的值。

let obj = {
    name: 'Sam',
    name: 'Jason'
};
console.log(obj.name) // 'jason'

　　新的方法

　　1, Object.is() 方法:  判斷兩個數是否相等。你可能有點差別，不是有 == 和 === 來判斷相等了嗎，怎麼還須要判斷相等的方法？ 不用擔憂，Object.is() 是用來處理極端狀況的，好比NaN. NaN 和任何數都不相等，包含它自己，沒有辦法直接比較，如今就能夠調用Object.is() 方法了，他就接受倆個要比較相等的參數。Object.is(NaN, NaN);  還有+0和-0， 對於js 引擎來講，他們兩個是不相等的，可是 用== 和=== 作判斷的時候，他們是相等的，爲了解決這種問題，就可使用Object.is(+0, -0) 

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

　　對於Object.is () 來講，你可能發現，咱們幾乎用不到它， 它就是對=== 操做符在某些極端狀況下的糾正，因此對於比較，咱們仍是用== 或===， 日常怎麼用就怎麼用，只有碰到極端狀況再用Object.is() 方法。 

　　2， Object.assign(): 並非新的方法，只是對各個框架中的mixin方法進行了標準化，既然各個框架中都實現了這個方法，那直接標準化就能夠了。用於將全部可枚舉屬性的值從一個或多個源對象複製到目標對象。它將返回目標對象。Object.assign(target, ...sources)，target 目標對象，sources： 源對象

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };

const returnedTarget = Object.assign(target, source);

console.log(target); // Object { a: 1, b: 4, c: 5 }

console.log(returnedTarget); // Object { a: 1, b: 4, c: 5 }

 　　3, Object.setPrototypeOf(), 設置一個對象的原型對象，它接受兩個參數，一個是對象，一個是對象要連接到的原型對象 。Object.setPrototypeOf(obj, prototypeObj).

let person = {
    greeting() {
        return "hello";
    }
}

let dog = {
    greeting() {
        return "woof";
    }
}

let obj = {};

// obj 連接到person 
Object.setPrototypeOf(obj, person);
console.log(obj.greeting()); // "hello"
// obj 連接到dog
Object.setPrototypeOf(obj, dog);
console.log(obj.greeting()); // woof

　　經過Object.setPrototypeOf() 方法能夠動態地改變一個對象的原型對象。這裏簡單說一下對象的原型，在js中沒有所謂的類式繼承，由於js中沒有java  中的類， 那Js中有什麼呢？ 它只有對象，當咱們把一個對象連接到原型對象上的時候，它是對象和對象之間的關係，就像上面中的代碼同樣， obj 就一個對象，它的原型對象不管是person， 仍是dog， 也是普通的對象， 對象和對象的連接關係，就像火車的車箱

經過鏈條連接起來同樣， 把每個車箱想象成每個對象。爲何把對象連接起來呢？ 由於另一個對象有咱們想要的方法，好比上面的greeting 方法。咱們剛剛聲明瞭一個對象obj,  空對象，什麼都沒有，剛要給他聲明一個greeting 方法，忽然發現person  對象有這個方法，那就不要聲明瞭，拿過來用就能夠了，這不，這兩個對象就有必要連接到一塊兒了。但執行obj.greeting()的時候，發現obj對象上並無這個方法，可是發現它連接到一個對象person, 那就順着鏈條繼續找吧，正好，person 對象上有這個方法，就調用了person 對象上的方法。就像火車上找人同樣，你先從第一車箱開始，沒有，由於第一車箱和第二車箱連接起來了，你就到第二車箱去找，仍是沒有，第二車箱又和第三車箱連接到一塊兒，你就去第三車箱去找，找到了，若是沒有找到，繼續第四車箱，由於每個車箱都是連接起來的。若是全部的車箱都找完了，仍是沒有，那就真沒有了。

　　那咱們還能不能在obj上面定義一個greeting 方法，由於有時候原型對象上的方法不能徹底知足要求？能夠，當咱們在一個對象上定義一個方法的時候，它就不會就找原型鏈了，直接調用對象上面的方法。

let obj = {
    greeting() {
        return 'obj';
    }
};

　　但有時候, 你發現，在obj 對象中定義的方法，可能使用到原型對象上的同名方法， 只要調用原型對象上面的方法再進行一下組裝就能夠達到要求了。ES6 提供了super 關鍵詞，它就指向原型對象

let obj = {
    greeting() {
        return super.greeting()  + 'obj';
    }
};

　　這裏要注意的是，對象方法的定義只能使用簡潔的語法形式，不然報錯。

　　super 是怎麼實現的呢？在ES6 中，若是一個對象中定義了方法，這個方法自動獲取到一個內置的屬性[[HomeObject]], 來指向這個對象。super 呢，就是經過Object.getPrototypeOf([[HomeObject]]) 來獲取到原型對象。obj.greeting() greeting() 方法中的[[HomeObject]] 就指向了obj.  那裏面的super 就是Object.getPrototypeOf(obj), 那就是person 或dog 了，super.greeting() 就至關於person.greeting()了， 更爲準確的說是 person.greeting.call(this).  由於若是person中的greenting有this, 咱們還要給它指定this 指向， 不能讓裏面的this 指向別的對象， 只能讓this 指向 obj 了。