ES6入门之对象的扩展

const f = 'a'
const b = {f}
b  // {f: 'a'}
等同于
const b = {f: f}

function u(x, y){
return {x, y}
}
// ====
function u(x, y){
return {x: x, y: y }
}
u(1, 2)   // {x:1, y: 2}
或者一下写法：
function o() {
const x = 1;
const x = 2;
return {x, y}
}
o() // {x:1, y:2}

//一
obj.foo = true
//二
obj['a' + 'bc'] = 123
//三
let t = 'm'
let obj = {
    [t]: true,
    ['a' + 'bc']: 123
}

let obj = {
    ['h' + 'ello']() {
return 'hi'
    }
}
obj.hello() // hi

const ka = {a: 1}
const kb = {b: 2}
const myObj = {
    [ka]: 'va',
    [kb]: 'vc'
}
myObj // Object {[object Object]: 'vc'}

const p = {
    n() {
        console.log('h')
    }
}
p.n.name // n

const obj = {
    get foo() {},
set fod() {}
}
obj.foo.name // undefined
const d = Object.getOwnPropertyDescriptor(obj, 'foo')
d.get.name // get foo
d.set.name // set fod

var do = function(){
}
do.bind().name // bound do

(new Function()).name // anonymous

const k = Symbol('描述')
k.name // "[描述]"

let obj = {f: 234}
Object.getOwnPropertyDescriptor(obj, 'foo')
//  {
//    value: 234,
//    writable: true,
//    enumerable: true,
//    configurable: true
//  }

有四个操作会忽略 enumerate 为 false 的属性
- for...in循环： 只遍历对象自身和继承的可枚举的属性
- Object.keys()：返回对象自身的所有可枚举的属性的键名
- JSON.stringify(): 只串行化对象自身的可枚举的属性
- Object.assign(): 忽略enumerable为false的属性，只
拷贝对象自身的可枚举的属性

（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 或字符串，也不管是否可枚举。 1）for..in
以上五种方法遍历对象的键名，都遵循同样的属性遍历的次序股则
    首先遍历所有数值键，按照数值升序排列。
    其次遍历所有字符串键，按照加入时间升序排列。
    最后遍历所有 Symbol 键，按照加入时间升序排列。

// 报错
const obj = {
foo: super.foo
}
// 报错
const obj = {
foo: () => super.foo
}
// 报错
const obj = {
foo: function () {
return super.foo
  }
}