6 函数的拓展

#6.1 参数默认值

// ES6 之前
function f(a, b){
    b = b || 'leo';
    console.log(a, b);
}

// ES6 之后
function f(a, b='leo'){
    console.log(a, b);
}

f('hi');          // hi leo
f('hi', 'jack');  // hi jack
f('hi', '');      // hi leo

注意:

• 参数变量是默认声明的，不能用let和const再次声明：

function f (a = 1){
    let a = 2; // error
}

• 使用参数默认值时，参数名不能相同：

function f (a, a, b){ ... };     // 不报错
function f (a, a, b = 1){ ... }; // 报错

与解构赋值默认值结合使用：

function f ({a, b=1}){
    console.log(a,b)
};
f({});         // undefined 1
f({a:2});      // 2 1
f({a:2, b:3}); // 2 3
f();           // 报错

function f ({a, b = 1} = {}){
    console.log(a, b)
}
f();  // undefined 1

尾参数定义默认值:
通常在尾参数定义默认值，便于观察参数，并且非尾参数无法省略。

function f (a=1,b){
    return [a, b];
}
f();    // [1, undefined]
f(2);   // [2, undefined]
f(,2);  // 报错

f(undefined, 2);  // [1, 2]

function f (a, b=1, c){
    return [a, b, c];
}
f();        // [undefined, 1, undefined]
f(1);       // [1,1,undefined]
f(1, ,2);   // 报错
f(1,undefined,2); // [1,1,2]

在给参数传递默认值时，传入undefined会触发默认值，传入null不会触发。

function f (a = 1, b = 2){
    console.log(a, b);
}
f(undefined, null); // 1 null

函数的length属性:
length属性将返回，没有指定默认值的参数数量，并且rest参数不计入length属性。

function f1 (a){...};
function f2 (a=1){...};
function f3 (a, b=2){...};
function f4 (...a){...};
function f5 (a,b,...c){...};

f1.length; // 1
f2.length; // 0
f3.length; // 1
f4.length; // 0
f5.length; // 2

#6.2 rest 参数

rest参数形式为（...变量名），其值为一个数组，用于获取函数多余参数。

function f (a, ...b){
    console.log(a, b);
}
f(1,2,3,4); // 1 [2, 3, 4]

注意：

• rest参数只能放在最后一个，否则报错：

function f(a, ...b, c){...}; // 报错 

• 函数的length属性不包含rest参数。

function f1 (a){...};
function f2 (a,...b){...};
f1(1);   // 1
f2(1,2); // 1

#6.3 name 属性

用于返回该函数的函数名。

function f (){...};
f.name;    // f

const f = function g(){...};
f.name;    // g

#6.4 箭头函数

使用“箭头”(=>)定义函数。
基础使用：

// 有1个参数
let f = v => v;
// 等同于
let f = function (v){return v};

// 有多个参数
let f = (v, i) => {return v + i};
// 等同于
let f = function (v, i){return v + i};

// 没参数
let f = () => 1;
// 等同于
let f = function (){return 1};

箭头函数与变量结构结合使用：

// 正常函数写法
function f (p) {
    return p.a + ':' + p.b;
}

// 箭头函数写法
let f = ({a, b}) => a + ':' + b;

简化回调函数：

// 正常函数写法
[1, 2, 3].map(function (x){
    return x * x;
})

// 箭头函数写法
[1, 2, 3].map(x => x * x);

箭头函数与rest参数结合：

let f = (...n) => n;
f(1, 2, 3); // [1, 2, 3]

注意点：

• 1.箭头函数内的this总是指向定义时所在的对象，而不是调用时。
• 2.箭头函数不能当做构造函数，即不能用new命令，否则报错。
• 3.箭头函数不存在arguments对象，即不能使用，可以使用rest参数代替。
• 4.箭头函数不能使用yield命令，即不能用作Generator函数。

不适用场景：

• 1.在定义函数方法，且该方法内部包含this。

const obj = {
    a:9,
    b: () => {
        this.a --;
    }
}

上述b如果是普通函数，函数内部的this指向obj，但是如果是箭头函数，则this会指向全局，不是预期结果。

• 2.需要动态this时。

let b = document.getElementById('myID');
b.addEventListener('click', ()=>{
    this.classList.toggle('on');
})

上诉按钮点击会报错，因为b监听的箭头函数中，this是全局对象，若改成普通函数，this就会指向被点击的按钮对象。

#6.5 双冒号运算符

双冒号暂时是一个提案，用于解决一些不适用的场合，取代call、apply、bind调用。
双冒号运算符(::)的左边是一个对象，右边是一个函数。该运算符会自动将左边的对象，作为上下文环境(即this对象)，绑定到右边函数上。

f::b;
// 等同于
b.bind(f);

f::b(...arguments);
// 等同于
b.apply(f, arguments);

若双冒号左边为空，右边是一个对象的方法，则等于将该方法绑定到该对象上。

let f = a::a.b;
// 等同于
let f = ::a.b;