// 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)把函数包在一个无参数的立即执行函数里面。