1.屬性的簡潔表示法：
ES6允許直接寫入變量和函數：
let birth = '2000/01/01';
const Person = {
name: '張三',
//等同於birth: birth
birth,
// 等同於hello: function ()...
hello() { console.log('我的名字是', this.name); }
};
如果某個方法的值是一個Generator函數，前面需要加上*號:
const obj = {
* m() {
yield 'hello world';
}
};
2.屬性名表達式：
JS定義對象的屬性，有兩種方式：
// 方法一
obj.foo = true;
// 方法二
obj['a' + 'bc'] = 123;
但是，如果使用字面量方式定義對象（使用大括號），在 ES5 中只能使用方法一（標識符）定義屬性。
var obj = {
foo: true,
abc: 123
};
ES6 允許字面量定義對象時，用方法二（表達式）作爲對象的屬性名，即把表達式放在方括號內。
let propKey = 'foo';
let obj = {
[propKey]: true,
['a' + 'bc']: 123
};
注意，屬性名表達式與簡潔表示法，不能同時使用，會報錯。
// 報錯
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"}
上面代碼中，[keyA]和[keyB]得到的都是[object Object]，所以[keyB]會把[keyA]覆蓋掉，而myObject最後只有一個[object Object]屬性。
3.方法的name屬性：
返回函數名（即方法名）:
如果對象的方法使用了取值函數（getter）和存值函數（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"
有兩種特殊情況：bind方法創造的函數，name屬性返回bound加上原函數的名字；Function構造函數創造的函數，name屬性返回anonymous
(new Function()).name // "anonymous"
var doSomething = function() {
// ...
};
doSomething.bind().name // "bound doSomething"
如果對象的方法是一個 Symbol 值，那麼name屬性返回的是這個 Symbol 值的描述
const key1 = Symbol('description');
const key2 = Symbol();
let obj = {
[key1]() {},
[key2]() {},
};
obj[key1].name // "[description]"
obj[key2].name // ""
4.Object.is();
ES5 比較兩個值是否相等，只有兩個運算符：相等運算符（==）和嚴格相等運算符（===）。它們都有缺點，前者會自動轉換數據類型，後者的NaN不等於自身，以及+0等於-0。
ES6 提出同值相等算法，用來解決這個問題。Object.is就是部署這個算法的新方法。它用來比較兩個值是否嚴格相等，與嚴格比較運算符（===）的行爲基本一致。不同之處只有兩個：一是+0不等於-0，二是NaN等於自身。
5.Object.assign();
Object.is('foo', 'foo')
// true
Object.is({}, {})
// false
+0 === -0 //true
NaN === NaN // false
Object.is(+0, -0) // false
Object.is(NaN, NaN) // true
Object.assign方法用於對象的合併，將源對象（source）的所有可枚舉屬性，複製到目標對象（target）。方法的第一個參數是目標對象，後面的參數都是源對象。
注意，如果目標對象與源對象有同名屬性，或多個源對象有同名屬性，則後面的屬性會覆蓋前面的屬性。
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}
除了字符串會以數組形式，拷貝入目標對象，其他值都不會產生效果。只拷貝源對象的自身屬性（不拷貝繼承屬性）
布爾值、數值、字符串分別轉成對應的包裝對象，可以看到它們的原始值都在包裝對象的內部屬性[[PrimitiveValue]]上面，這個屬性是不會被Object.assign拷貝的。只有字符串的包裝對象，會產生可枚舉的實義屬性，那些屬性則會被拷貝：
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" }
Object(true) // {[[PrimitiveValue]]: true}
Object(10) // {[[PrimitiveValue]]: 10}
Object('abc') // {0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"}
屬性名爲 Symbol 值的屬性，也會被Object.assign拷貝
Object.assign({ a: 'b' }, { [Symbol('c')]: 'd' })
// { a: 'b', Symbol(c): 'd' }
注意點：1）該方法爲淺拷貝，不是深拷貝，得到的是對象的引用
2）同名屬性的值會替換
3）可以用來處理數組，並視爲對象
Object.assign([1, 2, 3], [4, 5])
// [4, 5, 3]
上面代碼中，Object.assign把數組視爲屬性名爲 0、1、2 的對象，因此源數組的 0 號屬性4覆蓋了目標數組的 0 號屬性1
4）Object.assign只能進行值的複製，如果要複製的值是一個取值函數，那麼將求值後再複製：
const source = {
get foo() { return 1 }
};
const target = {};
Object.assign(target, source)
// { foo: 1 }
代碼中，source對象的foo屬性是一個取值函數，Object.assign不會複製這個取值函數，只會拿到值以後，將這個值複製過去。
常見用途：1）爲對象添加屬性
class Point {
constructor(x, y) {
Object.assign(this, {x, y});
}
}
2）爲對象添加方法
Object.assign(SomeClass.prototype, {
someMethod(arg1, arg2) {
···
},
anotherMethod() {
···
}
});
// 等同於下面的寫法
SomeClass.prototype.someMethod = function (arg1, arg2) {
···
};
SomeClass.prototype.anotherMethod = function () {
···
};
3）克隆對象
function clone(origin) {
return Object.assign({}, origin);
}
不過，採用這種方法克隆，只能克隆原始對象自身的值，不能克隆它繼承的值。如果想要保持繼承鏈，可以採用下面的代碼。
function clone(origin) {
let originProto = Object.getPrototypeOf(origin);
return Object.assign(Object.create(originProto), origin);
}
4)合併多個對象：
將多個對象合併到某個對象：
const merge =
(target, ...sources) => Object.assign(target, ...sources);
合併後返回一個新的對象：
const merge =
(...sources) => Object.assign({}, ...sources);
5）爲屬性指定默認值：
const DEFAULTS = {
logLevel: 0,
outputFormat: 'html'
};
function processContent(options) {
options = Object.assign({}, DEFAULTS, options);
console.log(options);
// ...
}
6.屬性的可枚舉性和遍歷：
可枚舉性：
對象的每個屬性都有一個描述對象（Descriptor），用來控制該屬性的行爲。Object.getOwnPropertyDescriptor方法可以獲取該屬性
的描述對象
let obj = { foo: 123 };
Object.getOwnPropertyDescriptor(obj, 'foo')
// {
// value: 123,
// writable: true,
// enumerable: true,
// configurable: true
// }
描述對象的enumerable屬性，稱爲”可枚舉性“，如果該屬性爲false，就表示某些操作會忽略當前屬性。
目前，有四個操作會忽略enumerable爲false的屬性。
for...in循環：只遍歷對象自身的和繼承的可枚舉的屬性。
Object.keys()：返回對象自身的所有可枚舉的屬性的鍵名。
JSON.stringify()：只串行化對象自身的可枚舉的屬性。
Object.assign()： 忽略enumerable爲false的屬性，只拷貝對象自身的可枚舉的屬性。
遍歷：
ES6 一共有 5 種方法可以遍歷對象的屬性。
（1）for...in ：
for...in循環遍歷對象自身的和繼承的可枚舉屬性（不含 Symbol 屬性）。
（2）Object.keys(obj)：
Object.keys返回一個數組，包括對象自身的（不含繼承的）所有可枚舉屬性（不含 Symbol 屬性）的鍵名。
（3）Object.getOwnPropertyNames(obj)：
Object.getOwnPropertyNames返回一個數組，包含對象自身的所有屬性（不含 Symbol 屬性，但是包括不可枚舉屬性）的鍵名。
（4）Object.getOwnPropertySymbols(obj)
Object.getOwnPropertySymbols返回一個數組，包含對象自身的所有 Symbol 屬性的鍵名。
（5）Reflect.ownKeys(obj)
Reflect.ownKeys返回一個數組，包含對象自身的所有鍵名，不管鍵名是 Symbol 或字符串，也不管是否可枚舉。
以上的 5 種方法遍歷對象的鍵名，都遵守同樣的屬性遍歷的次序規則。
首先遍歷所有數值鍵，按照數值升序排列。
其次遍歷所有字符串鍵，按照加入時間升序排列。
最後遍歷所有 Symbol 鍵，按照加入時間升序排列。
7 Object.setPrototypeOf方法：
Object.setPrototypeOf方法的作用與__proto__相同，用來設置一個對象的prototype對象，返回參數對象本身
// 格式
Object.setPrototypeOf(object, prototype)
// 用法
const o = Object.setPrototypeOf({}, null);
讀取一個對象的原型對象,若參數不是對象，則轉換成對象如果參數是undefined或null，它們無法轉爲對象，所以會報錯。
Object.getPrototypeOf(obj);
// 等同於 Object.getPrototypeOf(Number(1))
Object.getPrototypeOf(1)
// Number {[[PrimitiveValue]]: 0}
// 等同於 Object.getPrototypeOf(String('foo'))
Object.getPrototypeOf('foo')
// String {length: 0, [[PrimitiveValue]]: ""}
// 等同於 Object.getPrototypeOf(Boolean(true))
Object.getPrototypeOf(true)
// Boolean {[[PrimitiveValue]]: false}
Object.getPrototypeOf(1) === Number.prototype // true
Object.getPrototypeOf('foo') === String.prototype // true
Object.getPrototypeOf(true) === Boolean.prototype // true
8.super:
指向當前對象的原型對象
const proto = {
foo: 'hello'
};
const obj = {
find() {
return super.foo;
}
};
Object.setPrototypeOf(obj, proto);
obj.find() // "hello"
注意，super關鍵字表示原型對象時，只能用在對象的方法之中，用在其他地方都會報錯
// 報錯
const obj = {
foo: super.foo
}
// 報錯
const obj = {
foo: () => super.foo
}
// 報錯
const obj = {
foo: function () {
return super.foo
}
}
JavaScript 引擎內部，super.foo等同於Object.getPrototypeOf(this).foo（屬性）或Object.getPrototypeOf(this).foo.call(this)（方法）。
const proto = {
x: 'hello',
foo() {
console.log(this.x);
},
};
const obj = {
x: 'world',
foo() {
super.foo();
}
}
Object.setPrototypeOf(obj, proto);
obj.foo() // "world"
9.Object.keys():
ES5 引入了Object.keys方法，返回一個數組，成員是參數對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名
var obj = { foo: 'bar', baz: 42 };
Object.keys(obj)
// ["foo", "baz"]
ES2017 引入了跟Object.keys配套的Object.values和Object.entries，作爲遍歷一個對象的補充手段，供for...of循環使用。
Object.values方法返回一個數組，成員是參數對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值。返回數組的成員順序，與本章的《屬性的遍歷》部分介紹的排列規則一致。會過濾屬性名爲 Symbol 值的屬性。
如果Object.values方法的參數是一個字符串，會返回各個字符組成的一個數組。
Object.values('foo')
// ['f', 'o', 'o']
Object.entries方法返回一個數組，成員是參數對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值對數組。
const obj = { foo: 'bar', baz: 42 };
Object.entries(obj)
// [ ["foo", "bar"], ["baz", 42] ]
Object.entries的基本用途是遍歷對象的屬性
let obj = { one: 1, two: 2 };
for (let [k, v] of Object.entries(obj)) {
console.log(
`${JSON.stringify(k)}: ${JSON.stringify(v)}`
);
}
// "one": 1
// "two": 2
Object.entries方法的另一個用處是，將對象轉爲真正的Map結構
const obj = { foo: 'bar', baz: 42 };
const map = new Map(Object.entries(obj));
map // Map { foo: "bar", baz: 42 }
10.對象擴展運算符：
1）解構賦值：對象的解構賦值用於從一個對象取值，相當於將所有可遍歷的、但尚未被讀取的屬性，分配到指定的對象上面。所有的鍵和它們的值，都會拷貝到新對象上面。不能複製繼承自原型對象的屬性。
let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }
2）擴展運算符：（...）用於取出參數對象的所有可遍歷屬性，拷貝到當前對象之中。
let z = { a: 3, b: 4 };
let n = { ...z };
n // { a: 3, b: 4 }
//如果想完整克隆一個對象，還拷貝對象原型的屬性，可以採用下面的寫法。
// 寫法二
const clone2 = Object.assign(
Object.create(Object.getPrototypeOf(obj)),
obj
);
// 寫法三
const clone3 = Object.create(
Object.getPrototypeOf(obj),
Object.getOwnPropertyDescriptors(obj)
)