使用方式：...要展开的东西
展开运算符可以作用于可迭代对象，这样，就可以轻松的将可迭代对象转换为数组。

可以用于展开数组与对象，数组展开es6 对象展开es7

  1.         arr = [1,2,3,4,5,6]
  2.         console.log(arr)
  3.         console.log(...arr + '数组展开')
  4.         obj = {
  5.             name: '张三',
  6.             age:"15",
  7.         }
  8.         let obj1 = {
  9.             ...obj
  10.         }
  11.         console.log(obj)
  12.         console.log(obj1)
  13.         console.log(obj === obj1)

控制台效果
image.png
但是，当进行深度克隆时需要深入展开，才能实现深度克隆，否则只能浅度克隆
**

使用剩余参数与展开运算符实现函数柯里化

柯里化函数

  1. function curry(func, ...args) {
  2.             return function(...subArgs) {
  3.                 const allArgs = [...args, ...subArgs];
  4.                 if (allArgs.length >= func.length) {
  5.                     //参数够了
  6.                     return func(...allArgs);
  7.                 } else {
  8.                     //参数不够，继续固定
  9.                     return curry(func, ...allArgs);
  10.                 }
  11.             }
  12.         }

示例

  1.         function cal(a, b, c, d) {
  2.             return a + b * c - d;
  3.         }
  4.         //curry：柯里化，用户固定某个函数的前面的参数，得到一个新的函数，新的函数调用时，接收剩余的参数
  5.         function curry(func, ...args) {
  6.             return function(...subArgs) {
  7.                 const allArgs = [...args, ...subArgs];
  8.                 if (allArgs.length >= func.length) {
  9.                     //参数够了
  10.                     return func(...allArgs);
  11.                 } else {
  12.                     //参数不够，继续固定
  13.                     return curry(func, ...allArgs);
  14.                 }
  15.             }
  16.         }
  18.         const newCal = curry(cal, 1, 2)
  20.         console.log(newCal(3, 4)) // 1+2*3-4
  21.         console.log(newCal(4, 5)) // 1+2*4-5
  22.         console.log(newCal(5, 6)) // 1+2*5-6
  23.         console.log(newCal(6, 7)) // 1+2*6-7
  25.         const newCal2 = newCal(8)
  27.         console.log(newCal2(9)); // 1+2*8-9