ES6对象扩展

属性的简洁表示

• 属性的简洁表示，对象的key value不需要写value，只写key就可以定义。

let a = 12
let b = 13
let func = function() {...}
let obj = {a, b, func}  // {a: 12, b: 13, func: function(){...}}

属性名表达式

• 属性名称可以使用表达式，但是属性名表达式和属性简洁表示不能同时使用

let key = 'keyName'
let obj = {
  ['a' + 'b']: 12,
  [key]: 13,
  ['c' + 'd']() {...},  // 属性表达式也可以作为方法名
}
console.log(obj)  // {ab: 12, keyName: 13, cd: function(){}}

Object.is()

• 用来比较两个值是都相等，但是两个对象是不相等的，与严格相等（===）行为基本一致，不同的是:

NaN === NaN // false
Object.is(NaN, NaN)  // true
+0 === -0 // true
Object.is(+0, -0)  // false
Object.is({}, {})  // false  注意这一点

Object.assign()

• 将原对象的可枚举类型的值复制到目标对象中。如果原对象中有相同的属性，那么就会覆盖掉之前的属性。如果目标对象位置传入的参数不是对象，那么就会先转成对象再进行复制，但是null和undefined无法转成对象，所以就会报错。但是如果原对象参数位置传入的参数不是对象，不会报错。
• 基本用法是Object.assign(target, source1, source2)

let obj = {
  a: 1,
  b: 2
}
let obj2 = Object.assign({}, obj)
obj.c = 3
console.log(obj, obj2) //{a: 1, b: 2, c: 3}    {a: 1, b: 2}

属性的遍历

• for...in 遍历；遍历可枚举类型的属性

let obj = {
  a: 1,
  b:2
}
Object.defineProperty(obj, 'no_enum', {
  enumerable:false,
  value: '不可枚举类型'
})
for (let key in obj) {
  console.log(key)
}  // a   b

• Object.keys()；遍历可枚举类型的属性，返回对象所有的key值组成的数组

let obj = {
  a: 1,
  b:2
}
Object.defineProperty(obj, 'no_enum', {
  enumerable:false,
  value: '不可枚举类型'
})
for (let key of Object.keys(obj)) {
  console.log(key)
}   //  a    b

• Object.getOwnPropertyNames() ；遍历所有属性，不可枚举的属性也可以被遍历，返回数组

let obj = {
  a: 1,
  b: 2
}
Object.defineProperty(obj, 'no_enum', {
  enumerable:false,
  value: '不可枚举类型'
})
for (let key of Object.getOwnPropertyNames(obj)) {
  console.log(key)
}   //  a    b   no_enum

对象的遍历Object.keys()、Object.values()、Object.entries()

• Object.keys() 见上面“属性的遍历” ，只能遍历可枚举类型
• Object.values() 只能遍历可枚举类型

let obj = {
  a: 1,
  b: 2
}
Object.defineProperty(obj, 'no_enum', {
  enumerable:false,
  value: '不可枚举类型'
})
for (let value of Object.values(obj)) {
  console.log(value)
}   //  1   2

• Object.entries() 只能遍历可枚举类型

let obj = {
  a: 1,
  b: 2
}
Object.defineProperty(obj, 'no_enum', {
  enumerable:false,
  value: '不可枚举类型'
})
for (let [key, value] of Object.entries(obj)) {
  console.log(`${key}:${value}`)
}   //  a:1  b:2

对象的扩展运算符

• 解构赋值（浅复制），解构赋值右边不能是null或者undefined，只能是一个对象；解构赋值必须是最后一个参数，否则会报错

let {a, ...b} = {a: 1, b: 2, c: 3}
console.log(a, b)  // 1 , {b: 2, c: 3}
let {a, ...b} = null  // 报错，解构赋值右边不能是null或者undefined，只能是一个对象
let {...a, b} = {a: 1, b: 2}  // 报错，因为解构赋值必须是最后一个参数

• 扩展运算符，取出参数对象所有可遍历的属性，并将其复制到当前的对象中，和Object.assign()行为一致

let obj = {a: 1, b: 2, c:3}
let obj2 = {...obj}
obj.d = 4
console.log(obj, obj2)  //{a: 1, b: 2, c: 3, d: 4}   ,   {a: 1, b: 2, c: 3}

Null传导符 ?.

//  es5写法
let message = (res && res.data && res.data.info && res.data.info.message) || 'error'
// es6写法
let message = res?.data?.info?.message || 'error'

感谢您的view，留个赞再走呗

• 感谢浏览姑娘的文章，来自一个写前端的姑娘！