ES6扩展运算符(...)

在使用vuex的过程中,经常会碰到以下写法:

...mapGetters('user',['classList','class','subjectList','termList'])

在不了解ES6的扩展运算符前,对这种写法很迷惑,不懂...的作用到底是什么,于是通过《ECMAScript 6 入门》一书,学习了扩展运算符的相关知识。

数组的扩展运算符

  • 概念

    扩展运算符(spread)是三个点(...)。它好比 rest 参数的逆运算,将一个数组转为用逗号分隔的参数序列。扩展运算符与正常的函数参数可以结合使用,后面也可以放置表达式,但如果后面是一个空数组,则不产生任何效果。

    let arr = [];
    arr.push(...[1,2,3,4,5]);
    console.log(arr); //[1,2,3,4,5]
    console.log(1, ...[2, 3, 4], 5) //1 2 3 4 5
    console.log(...(1 > 0 ? ['a'] : [])); //a
    console.log([...[], 1]); //[1]
  • 意义

    1. 替代函数的apply方法

      由于扩展运算符可以展开数组,所以不再需要apply方法,将数组转为函数的参数了。

      // ES5 的写法
      Math.max.apply(null, [14, 3, 77])
      // ES6 的写法
      Math.max(...[14, 3, 77])
  • 应用

    1. 复制数组

      // ES5 的写法
      const a1 = [1, 2];
      const a2 = a1.concat();
      // ES6 的写法
      const a1 = [1, 2];
      const a2 = [...a1];
      //或
      const [...a2] = a1;
    2. 合并数组

      // ES5 的写法
      [1, 2].concat(more);
      arr1.concat(arr2, arr3);
      // ES6 的写法
      [1, 2, ...more];
      [...arr1, ...arr2, ...arr3]
    3. 与解构赋值结合

      // ES5 的写法
      a = list[0], rest = list.slice(1)
      // ES6 的写法
      [a, ...rest] = list

      注意:如果将扩展运算符用于数组赋值,只能放在参数的最后一位,否则会报错。

    4. 转换字符串

      扩展运算符还可以将字符串转为真正的数组,并且能够正确识别四个字节的 Unicode 字符。

      'x\uD83D\uDE80y'.length // 4
      [...'x\uD83D\uDE80y'].length // 3
      
      let str = 'x\uD83D\uDE80y';
      str.split('').reverse().join('') // 'y\uDE80\uD83Dx'
      [...str].reverse().join('')      // 'y\uD83D\uDE80x'
    5. 实现Iterator接口的对象

      任何 Iterator 接口的对象(参阅 Iterator 一章),都可以用扩展运算符转为真正的数组。

    6. Map和Set结构、Generator函数

      • 扩展运算符内部调用的是数据结构的 Iterator 接口,因此只要具有 Iterator 接口的对象,都可以使用扩展运算符,比如 Map 结构。
      let map = new Map([
       [1, 'one'],
       [2, 'two'],
       [3, 'three'],
      ]);
      
      let arr = [...map.keys()]; // [1, 2, 3]
      • Generator 函数运行后,返回一个遍历器对象,因此也可以使用扩展运算符。
      const go = function*(){
       yield 1;
       yield 2;
       yield 3;
      };
      
      [...go()] // [1, 2, 3]
      • 如果对没有 Iterator 接口的对象,使用扩展运算符,将会报错。

对象的扩展运算符

  • 概念

    对象的解构赋值用于从一个对象取值,相当于将目标对象自身的所有可遍历的(enumerable)、但尚未被读取的属性,分配到指定的对象上面。所有的键和它们的值,都会拷贝到新对象上面。

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

    注意:

    1. 由于解构赋值要求等号右边是一个对象,所以如果等号右边是undefinednull,就会报错,因为它们无法转为对象。

    2. 解构赋值必须是最后一个参数,否则会报错。

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

      let obj = { a: { b: 1 } };
      let { ...x } = obj;
      obj.a.b = 2;
      x.a.b // 2
    4. 扩展运算符的解构赋值,不能复制继承自原型对象的属性。

      let o1 = { a: 1 };
      let o2 = { b: 2 };
      o2.__proto__ = o1;
      let { ...o3 } = o2;
      o3 // { b: 2 }
      o3.a // undefined
      
      
      const o = Object.create({ x: 1, y: 2 });
      o.z = 3;
      
      let { x, ...newObj } = o;
      let { y, z } = newObj;
      x // 1
      y // undefined
      z // 3
      
      let { x, ...{ y, z } } = o;
      // SyntaxError: ... must be followed by an identifier in declaration contexts
  • 应用

    1. 扩展某个函数的参数,引入其他操作。

      function baseFunction({ a, b }) {
      // ...
      }
      function wrapperFunction({ x, y, ...restConfig }) {
      // 使用 x 和 y 参数进行操作
      // 其余参数传给原始函数
      return baseFunction(restConfig);
      }
    2. 取出参数对象的所有可遍历属性,拷贝到当前对象之中。

      let z = { a: 3, b: 4 };
      let n = { ...z };
      n // { a: 3, b: 4 }
      
      let aClone = { ...a };
      // 等同于
      let aClone = Object.assign({}, a);
      
      //上面的例子只是拷贝了对象实例的属性,如果想完整克隆一个对象,还拷贝对象原型的属性,可以采用下面的写法。
      // 写法一
      const clone1 = Object.assign(
      Object.create(Object.getPrototypeOf(obj)),
      obj
      );
      // 写法二
      const clone2 = Object.create(
      Object.getPrototypeOf(obj),
      Object.getOwnPropertyDescriptors(obj)
      )
    3. 合并两个对象。

      let ab = { ...a, ...b };
      // 等同于
      let ab = Object.assign({}, a, b);
      
      
      //如果用户自定义的属性,放在扩展运算符后面,则扩展运算符内部的同名属性会被覆盖掉。
      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 });
    4. 修改现有对象部分的属性。

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

      • 如果把自定义属性放在扩展运算符前面,就变成了设置新对象的默认属性值。
      • 与数组的扩展运算符一样,对象的扩展运算符后面可以跟表达式。
      • 如果扩展运算符后面是一个空对象,则没有任何效果。
      • 如果扩展运算符的参数是nullundefined,这两个值会被忽略,不会报错。
      • 扩展运算符的参数对象之中,如果有取值函数get,这个函数是会执行的。

你可能感兴趣的:(JavaScript)