簡潔表示法

{
    //簡潔表示法
    let o=1;
    let k=2;
    let es5={
        o:o,
        k:k
    }
    let es6={
        o,k
    }
    console.log(es5,es6)
    //{o: 1, k: 2} {o: 1, k: 2}

    let es5_m={
        hello:function(){
            console.log("hello")
        }
    }
    let es6_m={
        hello(){
            console.log('world')
        }
    }
    console.log(es5_m.hello(),es6_m.hello())
    //hello world

}

在對象中如果有函數(shù)，es6中采用簡潔表示，a(c){},如果在es6中定義一個(gè)函數(shù)，那么采用箭頭函數(shù)let a=(c)=>{}。

屬性表達(dá)式

{
    //屬性表達(dá)式
    let a='b';
    let es5_o={
        a:'c'
    }
    let es6_o={
        [a]:'c'//[a]的值是b
    }
    console.log(es5_o,es6_o[a])
    //{a: "c"} {b: "c"}
}

在屬性表達(dá)式中，es6可以采用變量的方式去定義key值，es5中的key值只能是固定的，在對象調(diào)用key值的時(shí)候，es6如果想采用key值，那么采取中括號的方式[]，.的方式不能得到變量。

方法的name屬性

函數(shù)的name屬性，返回函數(shù)名。對象方法也是函數(shù)，因此也有name屬性。

const person = {
  sayName() {
    console.log('hello!');
  },
};

person.sayName.name   // "sayName"

新增api

Object.is()
用來判斷兩個(gè)對象是否相等，在es5中NaN和NaN不相等，用這個(gè)方法相等。

{
    //新增api
    console.log(Object.is('abc','abc'))
    //true
    console.log(Object.is([1],[1]))
    //false數(shù)組是引用類型，地址不一樣，is()的功能和三個(gè)等號功能差不多
}

Object.assign()
方法用于將所有可枚舉的屬性的值從一個(gè)或多個(gè)源對象復(fù)制到目標(biāo)對象。它將返回目標(biāo)對象。
簡單的來說就是，在有指針的情況下，淺拷貝只是增加了一個(gè)指針指向已經(jīng)存在的內(nèi)存，而深拷貝就是增加一個(gè)指針并且申請一個(gè)新的內(nèi)存，使這個(gè)增加的指針指向這個(gè)新的內(nèi)存，采用深拷貝的情況下，釋放內(nèi)存的時(shí)候就不會出現(xiàn)在淺拷貝時(shí)重復(fù)釋放同一內(nèi)存的錯(cuò)誤！

Object.assign(target, ...sources)

{
    console.log(Object.assign({a:"a"},{b:"b"}))
    //{a: "a", b: "b"}只能是淺拷貝,即引用地址不會改變。
}
function test() {
  let a = { b: {c:4} , d: { e: {f:1}} }
  let g = Object.assign({},a)
  let h = JSON.parse(JSON.stringify(a));
  console.log(g.d) // { e: { f: 1 } }
  g.d.e = 32
  console.log('g.d.e set to 32.') // g.d.e set to 32.
  console.log(g) // { b: { c: 4 }, d: { e: 32 } }
  console.log(a) // { b: { c: 4 }, d: { e: 32 } }
  console.log(h) // { b: { c: 4 }, d: { e: { f: 1 } } }
  h.d.e = 54
  console.log('h.d.e set to 54.') // h.d.e set to 54.
  console.log(g) // { b: { c: 4 }, d: { e: 32 } }
  console.log(a) // { b: { c: 4 }, d: { e: 32 } }
  console.log(h) // { b: { c: 4 }, d: { e: 54 } }
}
test();

Object.entries()

{
    let test={k:123,o:456};
    for(let [key,value] of Object.entries(test)){
        console.log(key,value)
    }
}

proto屬性，Object.setPrototypeOf()，Object.getPrototypeOf()

Object.setPrototypeOf()相當(dāng)于proto,用來設(shè)置當(dāng)前對象的prototype對象，相當(dāng)于一個(gè)實(shí)例的proto等于構(gòu)造函數(shù)的prototype屬性。
proto屬性沒有寫入 ES6 的正文，而是寫入了附錄，原因是proto前后的雙下劃線，說明它本質(zhì)上是一個(gè)內(nèi)部屬性，而不是一個(gè)正式的對外的 API，只是由于瀏覽器廣泛支持，才被加入了 ES6。標(biāo)準(zhǔn)明確規(guī)定，只有瀏覽器必須部署這個(gè)屬性，其他運(yùn)行環(huán)境不一定需要部署，而且新的代碼最好認(rèn)為這個(gè)屬性是不存在的。因此，無論從語義的角度，還是從兼容性的角度，都不要使用這個(gè)屬性，而是使用下面的Object.setPrototypeOf()（寫操作）、Object.getPrototypeOf()（讀操作）、Object.create()（生成操作）代替。

// 格式
Object.setPrototypeOf(object, prototype)

// 用法
const o = Object.setPrototypeOf({}, null);

super關(guān)鍵字

this關(guān)鍵字總是指向函數(shù)所在的當(dāng)前對象，ES6 又新增了另一個(gè)類似的關(guān)鍵字super，指向當(dāng)前對象的原型對象。

const proto = {
  foo: 'hello'
};

const obj = {
  find() {
    return super.foo;
  }
};

Object.setPrototypeOf(obj, proto);
obj.find() // "hello"

上面代碼中，對象obj的find方法之中，通過super.foo引用了原型對象proto的foo屬性。

注意，super關(guān)鍵字表示原型對象時(shí)，只能用在對象的方法之中，用在其他地方都會報(bào)錯(cuò)。

擴(kuò)展運(yùn)算符，支持不好

{
    //擴(kuò)展運(yùn)算符
    let {a,b,...c}={a:'test',b:'kill',c:'ddd',d:"ccc"};
    c={
        c:"ddd",
        d:"ccc"
    }
}