默认参数

默认参数
JS 中，若函数没有传参也没有设置默认参数，则参数默认为 undefined，
若设置默认参数，且函数没有传参或传参为 undefined，则被设置为默认参数

  1.  function add(a, b=1) {
  2.      return a + b;
  3.  }
  4. add(2,2);  // 4
  5. add(2);    // 3

已经遇到的参数可用于以后的默认参数

  1. function add(a, b, result = a + b) {
  2.     return [a, b, result];
  3. }
  6. add(1, 2);   // [1, 2, 3]
  7. add(1, 2, 4);  // [1, 2, 4]

默认参数可设置在普通参数之前

  1. function f(x=1, y) {
  2.     return [x,y];
  3. }
  4. f();  // [1, undefined]
  5. f(2);  // [2, undefined]

通过解构赋值为参数赋值

  1. function f([x,y] = [1,2], {z:z} = {z: 3}) {
  2.     return x + y + z;
  3. }
  5. f(); // 6

剩余参数 Rest syntax

剩余参数
剩余参数允许我没将一个不定数量的参数表示为一个数组
语法：

  1. function(a, b, ...theArgs) {}
  2. (a, b, ...theArgs) => {}

示例：

  1. sum = (...theArgs) => theArgs.reduce((previous, current) => previous + current);
  2. sum(1, 2, 3); //6

解构剩余函数

  1. fn = (...[a, b, c]) => {
  2.     return a + b + c;
  3. }
  5. fn(1);           // NaN (b and a are undefined)
  6. fn(1, 2, 3);     // 6
  7. fn(1, 2, 3, 4);  // 6 (the fourth parameter is not destructured)

与 arguments 对象的区别：

  • 剩余函数只包括没有对应形参的实参，arguments 对象包括传给函数的所有实参
  • arguments 对象不是真正的数组，剩余函数是真正的 Array 示例，拥有数组的方法，如 sort, map, forEach, pop 等
  • arguments 对象有一些附加属性，如 callee

    展开运算符 Spread syntax(…)

    Spread syntax
    ... 可在函数调用、数组构造时，将可迭代（iterable）对象如 array 或 string 等在语法层面展开
    在函数调用时展开语法，等价于 apply 
    1. sum = (x, y, z) => x + y + z;
    2. const numbers= [1, 2, 3];
    3. sum(...numbers);  // 6
    4. sum.apply(null, numbers);  // 6
    构造数组
    1. var arr1 = ['a', 'b'];
    2. var arr2 = ['q', ... arr1, 'w']  // ['q', 'a', 'b', 'w']
    浅拷贝数组，相当于 Array.slice ```javascript var arr = [1, 2, 3]; var arr2 = […arr1]; // 相当于 arr.slice()

arr2.push(4) ; // arr2: [1, 2, 3, 4], arr: [1, 2, 3]

  1. 链接数组，相当于 Array.concat
  2. ```javascript
  3. var arr1 = [1, 2];
  4. var arr2 = [3, 4];
  5. var arr3 = arr1.concat(arr2); // [1, 2, 3, 4]
  6. var arr3 = [...arr1, ...arr2]; // [1, 2, 3, 4]

构造对象

  1. var obj1 = { foo: 'bar', x: 42 };
  2. var obj2 = { foo: 'baz', y: 13 };
  4. var clonedObj = { ...obj1 };
  5. // 克隆后的对象: { foo: "bar", x: 42 }
  7. var mergedObj = { ...obj1, ...obj2 };
  8. // 合并后的对象: { foo: "baz", x: 42, y: 13 }

与剩余参数的区别：两者相反，展开语法将数组展开为其中的各个元素，剩余语法将多个元素收集起来并“凝聚”为单个元素