美文网首页帖子收藏
ES6之扩展运算符-对象

ES6之扩展运算符-对象

作者: 付出的前端路 | 来源:发表于2018-06-27 12:22 被阅读0次

    Spread扩展运算符

    (1) 复制对象(深拷贝)

    拷贝了对象实例的属性
    对象的扩展运算符(...)用于取出参数对象的所有可遍历属性,拷贝到当前对象之中。

    let z = { a: 3, b: 4 };
    let n = { ...z };
    n // { a: 3, b: 4 }
    // 深拷贝
    z.a = 7
    console.log(z)  // {a: 7, b: 4}
    console.log(n) // {a: 3, b: 4}
    

    这等同于使用Object.assign方法。

    let aClone = { ...a };
    // 等同于
    let aClone = Object.assign({}, a);
    

    上面的例子只是拷贝了对象实例的属性,如果想完整克隆一个对象,还拷贝对象原型的属性,可以采用下面的写法。

    // 写法一
    const clone2 = Object.assign(
      Object.create(Object.getPrototypeOf(obj)),
      obj
    );
    
    // 写法二
    const clone3 = Object.create(
      Object.getPrototypeOf(obj),
      Object.getOwnPropertyDescriptors(obj)
    )
    

    注意点:...扩展运算符号只能是针对一维度的对象或数组进行拷贝。不能对多维进行拷贝

     const obj = {a: 1, b: 2}
       const {...x} = obj
       obj.a = 2
       console.log(x)  // {a: 1, b: 2}
    
       const obj2 = { a: { b: 1 } };
       const {...x2} = obj2
       obj2.a.b = 2;
       console.log(x2)  // {a: {b : 2}}
    
       const obj3 = {a: 1, b: function () {let a = 2}}
       const {...x3} = obj3
       obj3.b = function () {let a = 4}
       console.log(x3.b) // ƒ () {let a = 2}
    
       const obj4 = {a: {b: function () {let a = 2}}}
       const {...x4} = obj4
       obj4.a.b = function () {let a = 4}
       console.log(x4.a.b) // ƒ () {let a = 4}
    
    
    

    (2) 合并对象-深拷贝

    扩展运算符可以用于合并两个对象。

    let ab = { ...a, ...b };
    // 等同于
    let ab = Object.assign({}, a, b);
    
    // 深拷贝
    let z = { a: 3, b: 4 };
    let n = { c: 5, d: 6 };
    let test = {...z, ...n}
    z.a = 5
    console.log(test) // {a: 3, b: 4, c: 5, d: 6}
    

    如果用户自定义的属性,放在扩展运算符后面,则扩展运算符内部的同名属性会被覆盖掉。

    let aWithOverrides = { ...a, x: 1, y: 2 };
    // 等同于
    let aWithOverrides = { ...a, ...{ x: 1, y: 2 } };
    // 等同于
    let x = 1, y = 2, aWithOverrides = { ...a, x, y };
    // 等同于
    let aWithOverrides = Object.assign({}, a, { x: 1, y: 2 })
    

    上面代码中,a对象的x属性和y属性,拷贝到新对象后会被覆盖掉。

    这用来修改现有对象部分的属性就很方便了。

    let newVersion = {
      ...previousVersion,
      name: 'New Name' // Override the name property
    };
    

    上面代码中,newVersion对象自定义了name属性,其他属性全部复制自previousVersion对象。
    如果把自定义属性放在扩展运算符前面,就变成了设置新对象的默认属性值。

    let aWithDefaults = { x: 1, y: 2, ...a };
    // 等同于
    let aWithDefaults = Object.assign({}, { x: 1, y: 2 }, a);
    // 等同于
    let aWithDefaults = Object.assign({ x: 1, y: 2 }, a);
    

    与数组的扩展运算符一样,对象的扩展运算符后面可以跟表达式。

    const obj = {
      ...(x > 1 ? {a: 1} : {}),
      b: 2,
    };
    

    (3) 与解构赋值结合,用于生成对象

    解构赋值的拷贝是浅拷贝,即如果一个键的值是复合类型的值(数组、对象、函数)、那么解构赋值拷贝的是这个值的引用,而不是这个值的副本。

    let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
    x // 1
    y // 2
    z // { a: 3, b: 4 }
    
    // 浅拷贝
    let obj = { a: { b: 1 } };
    let { ...x } = obj;
    obj.a.b = 2;
    x.a.b // 2
    
    // 不能复制继承自原型对象的属性。
    let o1 = { a: 1 };
    let o2 = { b: 2 };
    o2.__proto__ = o1;
    let { ...o3 } = o2;
    o3 // { b: 2 }
    o3.a // undefined
    
    

    (4) 扩展某个函数的参数

    扩展某个函数的参数
    解构赋值的一个用处,是扩展某个函数的参数,引入其他操作。

    function baseFunction({ a, b }) {
      // ...
    }
    function wrapperFunction({ x, y, ...restConfig }) {
      // 使用 x 和 y 参数进行操作
      // 其余参数传给原始函数
      return baseFunction(restConfig);
    }
    

    上面代码中,原始函数baseFunction接受a和b作为参数,函数wrapperFunction在baseFunction的基础上进行了扩展,能够接受多余的参数,并且保留原始函数的行为。

    相关文章

      网友评论

        本文标题:ES6之扩展运算符-对象

        本文链接:https://www.haomeiwen.com/subject/gfebyftx.html