屬性的簡寫

ES6中，當對象鍵名與對應值相等的時候，可以進行簡寫

const baz = {foo:foo}

//等同于
const baz = {foo}

屬性名表達式

ES6允許字面量定義對象時，將表達式放在括號內

let lastWord = 'last Word';

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

表達式還可以用于定義方法名

let obj = {
  ['h' + 'ello']() {
    return 'hi';
  }
};

obj.hello() // hi

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

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

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

注意，屬性名表達式如果是一個對象，默認情況下會自動將對象轉為字符串[object Object]

const keyA = {a: 1};
const keyB = {b: 2};

const myObject = {
  [keyA]: 'valueA',
  [keyB]: 'valueB'
};

myObject // Object {[object Object]: "valueB"}

super關鍵字

this關鍵字總是指向函數所在的當前對象，ES6又新增了另一個類似關鍵字super,指向當前對象的原型對象

const proto = {
    foo:'hello'
}

const obj = {
    foo:'world',
    find(){
      return super.foo;
    }
}

Object.setPrototypeOf(obj,proto) //為obj設置原型對象
obj.find() // 'hello'

擴展運算符

在解構賦值中，未被讀取的可遍歷屬性，分配到指定的對象上面

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; // 修改obj里面a屬性中鍵值
x.a.b // 2，影響到了結構出來x的值

對象的擴展運算符等同于使用Object.assign()方法

屬性遍歷

ES6 一共有5種方法可以遍歷對象的屬性

• for...in:循環遍歷對象自身和繼承的可枚舉屬性（不含Symbol屬性）
• Object.keys(obj):返回一個數組，包括對象自身的（不含繼承的）可枚舉屬性，（不含Symbol屬性）
• Object.getOwnPropertyNames(obj): 返回一個數組，包含對象自身的所有屬性（不含 Symbol 屬性，但是包括不可枚舉屬性）的鍵名
• Object.getOwnPropertySymbols(obj):返回一個數組，包含對象自身的所有Symbol屬性的鍵名
• Reflect.ownKeys(obj):返回一個數組，包含對象自身的（不含繼承的）所有鍵名，不管鍵名是Symbol或字符串，也不管是否可枚舉

上述遍歷，都遵守同樣的屬性遍歷的次序規則：

• 首先遍歷所有數值鍵，按照數值升序排列
• 其次遍歷所有字符串鍵，按照加入時間升序排列
• 最后遍歷所有 Symbol 鍵，按照加入時間升序排

對象新增的方法

• Object.is()
• Object.assign()
• Object.getOwnPropertyDescriptors()
• Object.setPrototypeOf(),Object,getPrototypeOf()
• Object.keys(),Object.values(),Object.entries()
• Object.fromEntries()

Object.is()

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

+0 === -0 //true
NaN === NaN // false

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

Object.assign()

Object.assign()方法用于對象的合并，將源對象source的所有可枚舉屬性，復制到目標對象target
Object.assign()方法的第一個參數的目標對象，后面的是參數是源對象

const target = {a:1,b:1};

const source1 = {b:2,c:2};

const source2 = {c:3};

Object.assign(target,source1,source2);

target // {a:1,b:2,c:3}

注意：Object.assign()方法是淺拷貝，遇到同名屬性會進行替換

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.setPrototypeOf(),Object.getPrototypeOf()

設置一個對象的原型對象和讀取一個對象的原型對象

Object.keys()，Object.values()

返回自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名的數組
返回自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵對應值的數組

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

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

Object.entries()

返回一個對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值對的數組

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

Object.formEntries()

用于將一個鍵值對數組轉為對象

Object.fromEntries([
  ['foo', 'bar'],
  ['baz', 42]
])
// { foo: "bar", baz: 42 }