1. 屬性的間接表示法

• ES6 允許直接寫入變量和函數(shù)

  const foo = 'bar'
  const baz = {foo}  
  baz // {foo : 'bar'}
  // 等同于
  const baz = {foo : foo};

• 除屬性外 方法也可以簡寫

  const o = {
    method() { ...}
  }
  //等同于
  const o = {
    method : function () { ... }
  }

2. 屬性名表達式

ES6 允許字面量定義對象時，用方法二（表達式）作為對象的屬性名，即把表達式放在方括號內(nèi)

  let lastWord = 'last word';
  const a = {
    'first word': 'hello',
    [lastWord]: 'world'
  };
  a['first word'] // "hello"
  a[lastWord] // "world"
  a['last word'] // "world"

• 注意，屬性名表達式與簡潔表示法，不能同時使用，會報錯。

  // 報錯
  const foo = 'bar';
  const bar = 'abc';
  const baz = { [foo] };
  // 正確
  const foo = 'bar';
  const baz = { [foo]: 'abc'};

• 注意，屬性名表達式如果是一個對象，默認情況下會自動將對象轉(zhuǎn)為字符串[object Object]，這一點要特別小心。

  const keyA = {a: 1};
  const keyB = {b: 2};
  const myObject = {
    [keyA]: 'valueA',
    [keyB]: 'valueB'
  };
  myObject // Object {[object Object]: "valueB"}

3. 方法的 name 屬性

函數(shù)的name屬性，返回函數(shù)名。對象方法也是函數(shù)，因此也有name屬性。
如果對象的方法使用了取值函數(shù)（getter）和存值函數(shù)（setter），則name屬性不是在該方法上面，而是該方法的屬性的描述對象的get和set屬性上面，返回值是方法名前加上get和set。

  const obj = {
    get foo() {},
    set foo(x) {}
  };
  obj.foo.name
  // TypeError: Cannot read property 'name' of undefined
  const descriptor = Object.getOwnPropertyDescriptor(obj, 'foo');
  descriptor.get.name // "get foo"
  descriptor.set.name // "set foo"

如果對象的方法是一個 Symbol 值，那么name屬性返回的是這個 Symbol 值的描述。

4. Object.is()

Object.is 它用來比較兩個值是否嚴格相等，與嚴格比較運算符（===）的行為基本一致。不同之處只有兩個：一是+0不等于-0，二是NaN等于自身。

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

5. Object.assign()

Object.assign方法用于對象的合并,將源對象(source)的所有可枚舉屬性,復(fù)制到目標(target)對象 .

  const target = { a: 1 };
  const source1 = { b: 2 };
  const source2 = { c: 3 };
  Object.assign(target, source1, source2);
  target // {a:1, b:2, c:3}

Object.assign方法的第一個參數(shù)是目標對象,后面的參數(shù)都是源對象

• 注意，如果目標對象與源對象有同名屬性，或多個源對象有同名屬性，則后面的屬性會覆蓋前面的屬性。
• 如果只有一個參數(shù)，Object.assign會直接返回該參數(shù)。
• 如果該參數(shù)不是對象，則會先轉(zhuǎn)成對象，然后返回。
• 由于undefined和null無法轉(zhuǎn)成對象，所以如果它們作為參數(shù)，就會報錯。
• 其他類型的值（即數(shù)值、字符串和布爾值）不在首參數(shù)，也不會報錯。但是，除了字符串會以數(shù)組形式，拷貝入目標對象，其他值都不會產(chǎn)生效果。

  const v1 = 'abc';
  const v2 = true;
  const v3 = 10;
  const obj = Object.assign({}, v1, v2, v3);
  console.log(obj); // { "0": "a", "1": "b", "2": "c" }
  // v1、v2、v3分別是字符串、布爾值和數(shù)值，
  // 結(jié)果只有字符串合入目標對象（以字符數(shù)組的形式），數(shù)值和布爾值都會被忽略。

注意點
（1）淺拷貝
Object.assign方法實行的是淺拷貝，而不是深拷貝。也就是說，如果源對象某個屬性的值是對象，那么目標對象拷貝得到的是這個對象的引用。
（2）同名屬性的替換
對于這種嵌套的對象，一旦遇到同名屬性，Object.assign的處理方法是替換，而不是添加。
（3）同名屬性的替換
Object.assign可以用來處理數(shù)組，但是會把數(shù)組視為對象。

  Object.assign([1, 2, 3], [4, 5])  // [4, 5, 3]

（4）取值函數(shù)的處理
Object.assign只能進行值的復(fù)制，如果要復(fù)制的值是一個取值函數(shù)，那么將求值后再復(fù)制。

• 常見用途
  （1）為對象添加屬性
  （2）為對象添加方法
  （3）克隆對象 (采用這種方法克隆，只能克隆原始對象自身的值，不能克隆它繼承的值)
  （4）合并多個對象
  （5）為屬性指定默認值

6. 屬性的可枚舉性和遍歷

• 可枚舉型性
  對象的每個屬性都有一個描述對象（Descriptor），用來控制該屬性的行為。Object.getOwnPropertyDescriptor方法可以獲取該屬性的描述對象
  描述對象的enumerable屬性，稱為”可枚舉性“，如果該屬性為false，就表示某些操作會忽略當前屬性。
  目前，有四個操作會忽略enumerable為false的屬性。

for...in循環(huán)：只遍歷對象自身的和繼承的可枚舉的屬性。
Object.keys()：返回對象自身的所有可枚舉的屬性的鍵名。
JSON.stringify()：只串行化對象自身的可枚舉的屬性。
Object.assign()： 忽略enumerable為false的屬性，只拷貝對象自身的可枚舉的屬性。

• 屬性的遍歷
  ES6 一共有 5 種方法可以遍歷對象的屬性。
  （1）for...in
for...in循環(huán)遍歷對象自身的和繼承的可枚舉屬性（不含 Symbol 屬性）。
  （2）Object.keys(obj)
Object.keys返回一個數(shù)組，包括對象自身的（不含繼承的）所有可枚舉屬性（不含Symbol 屬性）的鍵名。
  （3）Object.getOwnPropertyNames(obj)
Object.getOwnPropertyNames返回一個數(shù)組，包含對象自身的所有屬性（不含 Symbol屬性，但是包括不可枚舉屬性）的鍵名。
  （4）Object.getOwnPropertySymbols(obj)
Object.getOwnPropertySymbols返回一個數(shù)組，包含對象自身的所有 Symbol 屬性的鍵名。
  （5）Reflect.ownKeys(obj)
Reflect.ownKeys返回一個數(shù)組，包含對象自身的所有鍵名，不管鍵名是 Symbol 或字符串，也不管是否可枚舉。

以上的 5 種方法遍歷對象的鍵名，都遵守同樣的屬性遍歷的次序規(guī)則。
首先遍歷所有數(shù)值鍵，按照數(shù)值升序排列。
其次遍歷所有字符串鍵，按照加入時間升序排列。
最后遍歷所有 Symbol 鍵，按照加入時間升序排列。

7. Object.getOwnPropertyDescriptors()

Object.getOwnPropertyDescriptor方法會返回某個對象屬性的描述對象（descriptor）。ES2017 引入了Object.getOwnPropertyDescriptors方法，返回指定對象所有自身屬性（非繼承屬性）的描述對象。

  const obj = {
    foo: 123,
    get bar() { return 'abc' }
  };

  Object.getOwnPropertyDescriptors(obj)
  // { foo:
  //    { value: 123,
  //      writable: true,
  //      enumerable: true,
  //      configurable: true },
  //   bar:
  //    { get: [Function: get bar],
  //      set: undefined,
  //      enumerable: true,
  //      configurable: true } }

• 該方法的引入目的，主要是為了解決Object.assign()無法正確拷貝get屬性和set屬性的問題。
• Object.getOwnPropertyDescriptors方法配合Object.defineProperties方法，就可以實現(xiàn)正確拷貝。
• Object.getOwnPropertyDescriptors方法的另一個用處，是配合Object.create方法，將對象屬性克隆到一個新對象。這屬于淺拷貝。
• Object.getOwnPropertyDescriptors也可以用來實現(xiàn) Mixin（混入）模式。

8. __proto__屬性，Object.setPrototypeOf() Object.getPrototypeOf()

• __proto__屬性
  都不要使用這個屬性，而是使用下面的Object.setPrototypeOf()（寫操作）、Object.getPrototypeOf()（讀操作）、Object.create()（生成操作）代替。
• Object.setPrototypeOf() 用來設(shè)置一個對象的prototype對象，返回參數(shù)對象本身。

  // 格式
  Object.setPrototypeOf(object, prototype)
  // 如果第一個參數(shù)不是對象，會自動轉(zhuǎn)為對象
  // 由于undefined和null無法轉(zhuǎn)為對象，
  //所以如果第一個參數(shù)是undefined或null，就會報錯。

• Object.getPrototypeOf() 用于讀取一個對象的原型對象

  Object.getPrototypeOf(obj);
  // 如果參數(shù)不是對象，會被自動轉(zhuǎn)為對象。
  // 如果參數(shù)是undefined或null，它們無法轉(zhuǎn)為對象，所以會報錯。

9. super 關(guān)鍵字

super，指向當前對象的原型對象。
super關(guān)鍵字表示原型對象時，只能用在對象的方法之中，用在其他地方都會報錯。

10. Object.keys()，Object.values()，Object.entries()

ES5 引入了Object.keys方法，返回一個數(shù)組，成員是參數(shù)對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名.
ES2017 引入了跟Object.keys配套的Object.values和Object.entries，作為遍歷一個對象的補充手段，供for...of循環(huán)使用。

• Object.keys() 返回一個數(shù)組，成員是參數(shù)對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名。
• Object.values() 返回一個數(shù)組，成員是參數(shù)對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名。
• Object.entries方法返回一個數(shù)組，成員是參數(shù)對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值對數(shù)組。

  const obj = { foo: 'bar', baz: 42 };
  Object.entries(obj)
  // [ ["foo", "bar"], ["baz", 42] ]

11. 對象的擴展運算符

• 解構(gòu)賦值
  對象的解構(gòu)賦值用于從一個對象取值,相當于將目標對象的所有可變的(enumerable),但尚未被讀取的屬性,分配到指定的對象上,所有的鍵和他們的值,都會拷貝到新的對象上.

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

(1) 由于解構(gòu)賦值要求等號右邊是一個對象，所以如果等號右邊是undefined或null，就會報錯，因為它們無法轉(zhuǎn)為對象。
(2) 解構(gòu)賦值必須是最后一個參數(shù)，否則會報錯。
(3) 解構(gòu)賦值的拷貝是淺拷貝，即如果一個鍵的值是復(fù)合類型的值（數(shù)組、對象、函數(shù)）、那么解構(gòu)賦值拷貝的是這個值的引用，而不是這個值的副本。
(4) 擴展運算符的解構(gòu)賦值，不能復(fù)制繼承自原型對象的屬性。

• 擴展運算符
  對象的擴展運算符（...）用于取出參數(shù)對象的所有可遍歷屬性，拷貝到當前對象之中。

  let aClone = { ...a };
  // 等同于
  let aClone = Object.assign({}, a);

合并對象

  let ab = { ...a, ...b };
  // 等同于
  let ab = Object.assign({}, a, b);

(1 )如果用戶自定義的屬性，放在擴展運算符后面，則擴展運算符內(nèi)部的同名屬性會被覆蓋掉。
(2) 如果把自定義屬性放在擴展運算符前面，就變成了設(shè)置新對象的默認屬性值。
(3) 與數(shù)組的擴展運算符一樣，對象的擴展運算符后面可以跟表達式。
(4) 如果擴展運算符后面是一個空對象，則沒有任何效果。
(5) 如果擴展運算符的參數(shù)是null或undefined，這兩個值會被忽略，不會報錯。
(6) 擴展運算符的參數(shù)對象之中，如果有取值函數(shù)get，這個函數(shù)是會執(zhí)行的。