ES6 允许为函数的参数设置默认值，即直接写在参数定义的后面。
参数默认值可以与解构赋值的默认值，结合起来使用。
ES6 允许使用“箭头”（=>）定义函数。
尾调用（Tail Call）是函数式编程的一个重要概念，本身非常简单，一句话就能说清楚，就是指某个函数的最后一步是调用另一个函数。

函数拓展

参数的默认值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
    // 参数默认值的写法
    function test1(x, y = 'world') {
        console.log(x, y);
    }
    test1('hello');  // hello world
    // 有默认值的参数后面不能接没有默认值的参数 以下为错误的做法
    function test2(x, y = 'world', c) {
        console.log(x, y, c);
    }
    test2('hello');  // 不会报错 但是会输出 c为 undefined
}

参数作用域的问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
    // 这里的函数的参数只会取到函数的传过来的参数，不会取到外面的 x
    let x = 'test';
    function test3(x, y = x) {
        console.log(x, y);
    }
    test3('hahaha'); // hahaha hahaha
    // 以下形式会使得 函数取到外面的变量
    let u = 'test';
    function test4(c, y = u) {
        console.log(c, y);
    }
    test4('hahaha'); // hahaha test
}

rest 参数 …arg

1
2
3
4
5
6
7
8
9
10
{
    // 在不确定有多少个参数的情况下 把传过来的参数转换成一个数组
    function test5(...arg) {
        for (let v of arg) {
            console.log(v);
        }
    }
    test5(1, 2, 4, 'a');  // 1,2,4,'a'
    // rest 参数后面不要再接其他的参数
}

拓展运算符

1
2
3
4
5
6
7
{
    // 把数组 拆分成离散的值
    console.log(...[1, 2, 3]); // 1,2,3   
    // 可以组合使用
    console.log('a', ...[1, 2, 3]) // a,1,2,3 
}

箭头函数

1
2
3
4
5
6
7
8
{
    // 函数名称 = 参数 => 返回值
    let arrow1 = v => v * 3;
    let arrow2 = () => 5;
    console.log(arrow1(3));  // 9
    console.log(arrow2());   // 5
}

尾调用

1
2
3
4
5
6
7
8
9
10
{
    // 再解决递归的问题的时候这个是个良好的解决办法。节省资源和优化性能
    function tail(x) {
        console.log(x);
    }
    function fx(x) {
        return tail(x);
    }
    fx(123); // 123
}