簡介表示法（直接寫入變量和函數，作為對象的屬性和方法）

let x = "test"
let obj={
    x,  //屬性名為變量名，屬性值為變量值
    y(){console.log("hello")}   
}
//以上相當於
let obj = {
    x:‘test‘,
    y:function(){
        console.log("hello")
    }
}

屬性名表達式（表達式作為對象的屬性名，把表達式放在方括號內。）

let aa = "hello";
let obj = {
    [aa]: "hello",
    ["a" + "b"]: "es6"
}
 
//以上相當於
let obj = {
    hello: "hello",
    "ab": "es6"
}

對象方法的name屬性（返回函數名）

let obj = {
    "hello": "hello",
    foo: function () {

    }
}
console.log(obj.foo.name)

Object.is()（比較兩個值是否嚴格相等，相當於===，但是-0不等於0，NaN=NaN）

Object.is({}, {}) //false
Object.is(-0, 0) //false
Object.is(NaN, NaN) //true

Object.assign()

let obj1 = {a:1};
let obj2 = {b:2};
let objx = {b:4};
let obj3 = Object.assign(obj1,obj2); //{ a: 1, b: 2 }
let obj4 = Object.assign(obj1,obj2,obj3) //{ a: 1, b: 4 }   如果有相同的屬性名，後者覆蓋前者

註意：

• 淺拷貝對象（源對象某個屬性的值是對象，那麽目標對象拷貝得到的是這個對象的引用。）

const obj1 = {a: {b: 1}};
const obj2 
 
= Object.assign({}, obj1);

obj1.a.b = 2;
obj2.a.b // 2

• 處理數組

//把數組的索引當做key來生成對象
Object.assign([1, 2, 3], [4, 5]) //[4,5,3]

• 取值函數（先取值，後復制）

const source = {
    get foo(){
        return 1
    }
}
let a =Object.assign({},source) //{ foo: 1 }

Object.keys()，Object.values()，Object.entries()（都返回數組形式）

let obj = {a: 0,b: 1,c: 2};
let a = Object.keys(obj)    //["a","b","c"]
let b = Object.values(obj)  //[0,1,2]
let c = Object.entries(obj) //[["a":0],["b":1],["c":2]]

擴展運算符...

• 解構賦值（解構賦值的拷貝是淺拷貝）

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }

let obj = { a: { b: 1 } };
let { ...x } = obj;
obj.a.b = 2;
x.a.b // 2

• 擴展運算符（取出參數對象的所有可遍歷屬性，拷貝到當前對象之中）

let z = { a: 3, b: 4 };
let n = { ...z };   // { a: 3, b: 4 }

//等同於
let n = Object.assign({},z) // { a: 3, b: 4 }

ES6學習之對象擴展