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();//
         a=0;
         foo();//

         // 上面代码中，参数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);//
         console.log((function(a=1){}).length)//

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

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

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

         var x=1;
         function f(x,y=x){
             console.log(y);
         }
         f(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);//

         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));//

     //严格模式

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