Object

Object属性能够简写吗？
- 申明一个object，key和value一样能够省略
- 下面的key必须是字符串，如果key外面要加动静变量（计算属性名）
- 办法的简写
- ES6能够增加异步函数
怎么把一个对象复制到另一个对象中？—— Object.assign()
- 如果source和target有雷同属性
- 如果target不是对象
- 如何应用？
- 解决什么问题？
- 有点缺点？
对象扩大办法 —— Object.is()
ES6-ES10学习幅员

Object属性能够简写吗？

申明一个object，key和value一样能够省略

//ES5 申明一个变量let x = 1let y = 3let obj = {    x: x,    y: y}//ES6let obj = {    x,    y}

下面的key必须是字符串，如果key外面要加动静变量（计算属性名）

//ES5let x = 1let y = 3let obj = {    x: x}obj[y] = 5console.log(obj)//{3: 5, x: 1}//ES6let x = 1let y = 3let z = 2let obj = {    x: x    [y]: 6,    [z + y]: 8}console.log(obj)//{3: 6, x: 1, 5: 8}

办法的简写

//ES5let obj = {    x: 1,    hello: function () {        console.log('hello')    }}//ES6let obj = {    x: 1,    hello () { // 简写        console.log('hello')    }}obj.hello()

ES6能够增加异步函数

let obj = {    x: 1,    * hello () { // 等同于function * functionName() {}        console.log('hello')    }}obj.hello() // （输入为空）

怎么把一个对象复制到另一个对象中？—— Object.assign()

Object.assign(target, ...sources) 
 
target 是指标对象必选 
sources 是源对象非必选 
此办法用域将所有可枚举属性的值从一个或多个源对象复制到指标对象，它将返回指标对象 (浅复制)

如果source和target有雷同属性

如果是0个源对象，则间接返回指标对象，如果对象有雷同的属性，那么源对象的属性会笼罩掉指标对象中的属性

const source1 = {  a: 123,  b: 123}const target = {  a: 456,  c: 456}const result = Object.assign(target, source1)console.log(target)// { a: 123, c: 456, b: 123 }console.log(target === result)// true

如果target不是对象

如果target不是对象，则主动转换为对象

let t = Object.assign(2)// Number {2}let s = Object.assign(2, {a: 2})// Number {2, a: 2}

如何应用？

如何将上面的source对象拷贝到target对象中呢？

const target = {}const source = {b: 4, c: 5}// ES5 把souce遍历一下，把外面的数据一一拷贝到target中// 尽管原理简略，然而实际操作进去还是比拟麻烦的// ES6Object.assign(target, source)console.log(source, 'source')

解决什么问题？

拷贝之后，如果要批改外面name的值，外界也会跟着批改

function func(obj) {  obj.name = 'func obj'  console.log(obj) // { name: 'func obj' }}const obj = {  name: 'global obj'}func(obj)console.log(obj) // { name: 'func obj' }

防止这种状况，应用assign复制到一个新对象下面

function func(obj) {  const funcObj = Object.assign({}, obj)  funcObj.name = 'func obj'  console.log(funcObj)  // { name: 'func obj' }}const obj = {  name: 'global obj'}func(obj)console.log(obj) //   { name: 'global obj' }

有点缺点？

下面那个办法是有缺点的: 
当赋值援用类型的值的时候，间接替换地址而不论外面的值

const target = {    a: {        b: {            c: {                d: 4            }        }    },    e: 5,    f: 6,    h: 10}const source = {    a: {        b: {            c: {                d: 1            }        }    },    e: 2,    f: 3}Object.assign(target, source)console.log(target)/*{    a: {        b: {            c: {                d: 1            }        }    },    e: 2,    f: 3}*/// 如果target是空对象或者和source对象严格格局雷同时进行了替换感觉没啥问题，然而下面的式子能够看进去，Object.assign进行的是浅拷贝，当复制的是援用类型，那么会将地址整体进行替换。所以h并没有保留。

解决形式 ——> Object.assign + 递归

对象扩大办法 —— Object.is()

ES5之前咱们判断两个变量相等应用的是==和===，两个等号在运算的时候，会先转换数据类型，所以会遇到0 == false为true的状况，而三等号除了比拟数值，还会比拟类型。

然而上面三个等号，也会呈现一些状况，应用is办法能够失去正确的后果。不过个别状况还是倡议应用三个等号。

console.log(-0 === +0) // trueconsole.log(Object.is(-0, +0)) // falseconsole.log(NaN === NaN) // falseconsole.log(Object.is(NaN, NaN)) // true