属性的简洁表示法

let baz = {foo}
等同于
let baz = {foo: foo}

上面的代码表明，ES6允许在对象中只写属性名，不写属性值。这时，属性值等于属性名所代表的变量。
除了属性简写，方法也可以简写。

let o = {
   method () {
       return 'hello'
    }
}
等同于
let o = {
   method: function () {
        return 'hello'
   }
}

属性的赋值器（setter）和取值器（getter）事实上也采用了这种写法。

let cart = {
   _wheel: 4,
   get wheels () {
        return this._wheel
    },
    set wheels (value) {
        this._wheel = value
   }
}

属性名表达式

javascript语言定义对象的属性有两种方法

// 方法一
obj.foo = true
// 方法二
obj['a' + 'bc'] = 123

但是如果使用字面量方式定义对象（使用大括号），则在ES5中只能使用方法一定义属性

let obj = {
    foo: true,
    abc: 123
}

ES6允许字面量定义对象时用方法二，即把表达式放在方括号内

let propKey = 'foo'
let obj = {
   [propKey]: true,
   ['a' + 'bc']: 123
}

这种方式还可以用于定义方法名

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

注意，属性名表达式与简洁表示法不能同时使用，否则会报错

let foo = 'bar'
let baz = 'abc'
let bar = '{[foo]}'
// 报错
let foo = 'bar'
let bar = '{[foo]: 'abc'}'
// 正确

注意：属性名表达式如果是一个对象，默认情况下会自动转为字符串[object, object]

const = keyA = {a:1}
const obj = {
    [keyA]: 'value'
}
obj     // {[object, object]: 'value'}

Object.is()

ES5比较两个值是否相等，只有两个运算符：==或===。
它们都有缺点，前者会自动转换数据类型，一般不用，后者的NaN不等于自身，以及+0等于-0。所以ES6提出了同值相等算法用来解决这个问题。
Object.is方法跟===的行为基本一致。不同之后只有两个：一个是+0不等于-0，二是NaN等于自身。

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

Object.assign()

基本用法

Object.assign方法用于将源对象的所有可枚举属性复制到目标对象。第一个参数是目标对象，后面的参数是源对象。
注意：如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。

let a = {a: 1, b: 1}
let b = {b: 2, c: 2}
let c = {c: 3}
Object.assgin(a, b, c) // {a: 1, b: 2, c: 3}

转换规则
如果参数不是对象，则会转为对象，如果无法转为对象便会跳过，但是针对undefined、null处理不同。
如果是首参数，由于undefined、null无法转为对象，所以如果将它们作为参数，就会报错，如果不是首参数，便会跳过。
这个方法对字符串还有数组处理都不同，但是我们不考虑其他情况，只考虑对象、undefined、null这三种情况
注意点
Object.assign方法实行的是浅复制而不是深复制，也就是说，如果源对象某个属性的值是对象，那么目标对象复制得到的是这个对象的引用。

let obj1 = {a: {b: 1}}
let obj2 = Object.assign({}, obj1)
obj1.a.b = 2
obj2.a.b = 2

属性的可枚举性

描述对象的enumerable属性称为"可枚举性"，如果该属性为false，就表示某些操作会忽略当前属性。
ES5有3个操作会忽略enumerable为false的属性

• for ...in
• Object.keys()
• JSON.stringify()
• Object.assign()

属性的遍历

1.for in：循环遍历对象自身和继承的可枚举属性（不含Symbol属性）
2.Object.keys：返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含Symbol属性）
3.Object.getOwnPropertyNames：返回一个数组，包含对西那个自身的所有属性（不含Symbol属性，但是包括不可枚举属性）
4.Object.getOwnPropertySymbols：返回一个数组，包含对象自身的所有Symbol属性
5.Reflect.ownKeys：返回一个数组，包含对象自身的所有属性，不管属性名是Symbol还是字符串，也不管是否可枚举

proto属性、Object.setPrototypeOf()、Object.getPrototypeOf()

proto属性

proto属性用来读取或设置当前对象的prototype对象。它本质上是一个内部属性，而不是一个正式的对外API，所以不要使用它。而是使用Object.setPrototypeOf()（写操作）、Object.getPrototypeOf()（读操作）或Object.create()（生成操作）

Object.setPrototypeOf

Object.setPrototypeOf方法的作用与proto相同，用来设置一个对象的prototype对象。

Object.setPrototypeOf(obj, proto)
等同于
function (obj, proto) {
    obj.__proto__ = proto
    return obj
}
下面是一个例子
let proto = {}
let obj = {x:10}
Object.setPrototypeOf(obj, proto)
proto.y = 20
proto.z = 40
obj.x   // 10
obj.y   // 20
obj.z  // 40

Object.getPrototypeOf

该方法与setPrototypeOf方法配套，用于读取一个对象的prototype对象。

function Rectangle () {}
let rec = new Rectangle()
Object.getPropertypeOf(rec) === Rectangle.prototype

注意：Object.setPrototypeOf、Object.getPrototypeOf的第一个参数为undefined或null都会报错

Object.keys()、Object.values()、Object.entries()

ES5引入了Object.keys()，返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键名。ES7引入了与Object.keys()配套的Object.values()、Object.entries()作为遍历一个对象的补充手段，供for of循环使用。

let obj = {a: 100, b: 200, c: 300}
Object.keys(obj)         // [a, b, c]
Object.values(obj)      // [100, 200, 300]
Object.entries(obj)     // [['a', 100], ['b', 200], ['c', 300]]

这三个方法都是返回一个数组，包括对象自身的（不可继承的）所有属性或值或属性值（不包含Symbol属性）

对象的扩展运算符

对象的解构赋值用于从一个对象取值，相当于将所有可遍历的、但尚未被读取的属性分配到指定的对象上面。所有的键和它们的值都会复制到新对象上面。

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

由于解构赋值要求等号右边是一个对象，所以如果等号右边是undefined或null就会报错，因为它们无法转为对象。解构赋值必须是最后一个参数，否则会报错，解构赋值是浅拷贝并且不会复制继承自原型对象的属性

扩展运算符

用于取出参数对象的所有可遍历属性，并将其复制到当前对象之中。

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

这等同于使用Object.assign方法
扩展运算符可用于合并两个对象，如果用户自定义的属性放在扩展运算符的后面，扩展运算符内部的同名属性会被覆盖。

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

如果扩展运算符的参数是undefined或ull，则这两个参数会被忽略，不会报错

let obj = {...undefined, ...null} 
obj // {}

扩展运算符的参数对象中有取值函数get，这个函数会被执行

let obj = {
   ...a,
   get x() {
      throw new Error('not throw yet')
  }
}

扩展运算符后面都可以带有表达式

Object.getOwnPropertyDescriptors()

ES5的Object.getOwnPropertyDescriptor方法用来返回某个对象属性的描述对象
ES7引入了Object.getOwnPropertyDescriptors方法，返回指定对象所有自身属性（非继承属性）的描述对象。

const obj = {
   foo: 123,
   get bar() {return 'abc'}
}
Object.getOwnPropertyDescriptors(obj)
{
 foo: 
   {
      value: 123,
      writable: true,
      enumerable: true,
      configurable: true
   },
  bar: 
   {
      value:'abc',
      writable: true,
      enumerable: true,
      configurable: true
   }
}

Null传导运算符

编程过程中，如果读取对象内部的某个属性，往往需要判断该对象是否存在。比如，要读取message.body.user.firstName,安全的写法如下：

const firstName = {
    message && message.body
    && message.body.user
    && message.body.user.firstName || 'default'
}

这样层层判断非常麻烦，因此有一个现在有一个提案，引入"Null传导运算符"?.,可以简化上面的写法。

const firstName = message ? .body ? .user ? .firstName || 'default'

上面有三个?.运算符，只要其中一个返回null或undefined，就不再继续运算，而是返回undefined。
Null传导运算符有4种用法

• obj ?.prop：读取对象属性
• obj ?. [prop]：同上
• func ?. (...args)：函数或对象方法的调用
• new C ?. (...args)：构造函数的调用
  传导运算符之所以写成obj ?.prop 而不是obj ? prop是为了区别三目运算符。