ES6_入门（6）_函数的扩展

// 2017/7/22
        /*ES6函数的扩展*/
        //ES6 之前，不能直接为函数的参数指定默认值，只能采用变通的方法。
        function log(x, y) {
          y = y || 'World';
          console.log(x, y);
        }

        log('Hello') // Hello World
        log('Hello', 'China') // Hello China
        log('Hello', '') // Hello World
        log('Hello', '0') // Hello 0
        log('Hello', 0) //Hello World

          console.log("0"==false);//true
          console.log(0==false);//true

         //注意：这种写法的缺点在于，如果参数y赋值了，但是对应的布尔值为false，则该赋值不起作用。就像上面代码的最后一行，参数y等于空字符，结果被改为默认值。

         //问题：数字0和字符串“0”的布尔值都为false,但是调用log函数的结果不一样。

         //为了避免这个问题，通常需要先判断一下参数y是否被赋值，如果没有，再等于默认值。

         function log(x, y) {
             if(typeof y===undefined){
                 y="World";
             }
         
          console.log(x, y);
        }

        log('Hello') // Hello undefined
        log('Hello', 'China') // Hello China
        log('Hello', '') // Hello 
        log('Hello', '0') // Hello 0
        log('Hello', 0) //Hello 0


        //ES6 允许为函数的参数设置默认值，即直接写在参数定义的后面。
        function log(x,y="world"){
            console.log(x,y);
        }
        log('Hello');//Hello world
        log('Hello','');//Hello 
        log('Hello','China');//Hello China
        log('Hello',0)//Hello 0

        //注意：参数变量是默认声明的，在函数体中不能用let和const再次声明。
        function foo(x=8){
            let x=3;
            const x=3;
        }
        foo();//Uncaught SyntaxError: Identifier 'x' has already been declared



        //注意：参数默认值不是传值的，而是每次都重新计算默认值表达式的值。也就是说，参数默认值是惰性求值的。

        let a=99;
        function foo(x=a+1){
            console.log(x);
        }
        foo();//100
        a=0;
        foo();//1

        // 上面代码中，参数x的默认值是a + 1。这时，每次调用函数foo，都会重新计算a + 1，而不是默认x等于 100。


        //2017/7/24
        //与解构赋值默认值结合使用
        function foo({x,y=5}){
            console.log(x,y);
        }

        foo({});//undefined 5
        foo({x:1});//1,5
        foo({x:1,y:2});//1,2
        foo();//Uncaught TypeError: Cannot match against 'undefined' or 'null'.

        //注意：只有当函数foo的参数是对象时，变量x和y才会通过解构赋值而生成。如果函数foo调用时参数不是对象，变量x和y就不会生成，从而报错。

        //写法一
        function m1({x=0,y=0}={}){
            console.log(x,y);
        }

        // //写法二
        function m2({x,y}={x:0,y:0}){
            console.log(x,y);
        }

        m1();//0 0
        m2();//0 0

        m1({x:3,y:4});//3 4
        m2({x:3,y:4});//3 4

        m1({});//0 0
        m2({});//undefined undefined

        m1({z:3});//0 0
        m2({z:3});//undefined undefined

        //参数默认值的位置

        //注意：定义了默认值的参数，应该是函数的尾参数。因为这样比较容易看出来。如果是非尾部的参数设置默认值，实际上这个参数是没法省略的。

        function f(x=1,y){
            console.log(x,y);
        }
        f();//1 undefined
        f(2);//2 undefined
        // f(,1);//Uncaught SyntaxError: Unexpected token ,
        f(undefined,1);//1 1

        function f(x,y=5,z){
            console.log(x,y,z);
        }

        f();//undefined 5 undefined
        f(1);//1 5 undefined
        f(1,2,3);//1 2 3
        // f(1,,2);//报错：es6.html:971 Uncaught SyntaxError: Unexpected token ,
        f(1,undefined,2);//1 5 2

        //传入undefined，将触发该参数等于默认值，null则没有这个效果。
        function foo(x=5,y=6){
            console.log(x,y);
        }

        foo(undefined,null);//5 null

    
        //函数的 length属性
        //注意：为函数的参数指定默认值后，函数的length属性将会失真，因为函数的length属性返回的是没有指定默认值的参数个数。
        //length属性的含义是：该函数预期传入的参数个数。某个参数指定默认值以后，预期传入的参数个数就不包括这个参数了。同理，rest参数也不会计入length属性。
        console.log((function(a){}).length);//1
        console.log((function(a=1){}).length)//0

        console.log((function(...args){}).length);//0

        //如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了。
        console.log((function(a=1,b,c){}).length);//0
        console.log((function(a,b=1,c){}).length);//1

        //作用域：
        //一旦设置了参数的默认值，函数进行声明初始化时，参数会形成一个单独的作用域（context）。等到初始化结束，这个作用域就会消失。这种语法行为，在不设置参数默认值时，是不会出现的。

        var x=1;
        function f(x,y=x){
            console.log(y);
        }
        f(2);//2

        let x=1;
        function f(y=x){
            let x=2;//
            console.log(y);
        }
        f();//1,函数f调用时，参数y = x形成一个单独的作用域。这个作用域里面，变量x本身没有定义，所以指向外层的全局变量x。函数调用时，函数体内部的局部变量x影响不到默认值变量x。
        f(3);//3


        function f(y=x){
            let x=2;
            console.log(y);
        }
        f();//es6.html:1012 Uncaught ReferenceError: x is not defined
         
        var x=1;
        function f(x=x){
            console.log(x);
        }
        f();//Uncaught ReferenceError: x is not defined
        /*注意：以上代码，参数x=x形成一个单独的作用域，实际上执行的是let x=x，由于暂时性死区的原因报错，在变量x的声明语句还没有执行完成前，就去取x的值，导致报错”x 未定义“。*/

        /*应用*/
        //(1)利用参数默认值，可以指定某一个参数不得省略，如果省略就抛出一个错误。
        //(2)可以将参数默认值设为undefined，表明这个参数是可以省略的。


        //rest参数:ES6 引入 rest 参数（形式为...变量名）。
        function f(...values){
            let sum=0;
            for(var val of values){
                sum+=val;
            }
            return sum;
        }

       console.log(f(4,5,1));//10

    
    //严格模式

    //(1)从 ES5 开始，函数内部可以设定为严格模式。
    //(2)ES2016 做了一点修改，规定只要函数参数使用了默认值、解构赋值、或者扩展运算符，那么函数内部就不能显式设定为严格模式，否则会报错。
    /*如何规避*/
    //(1)第一种是设定全局性的严格模式，这是合法的。
    //(2)把函数包在一个无参数的立即执行函数里面。