ES6_入门（4）_数组的解构赋值

     //2017/7/14
         //变量的解构赋值(解构：Destructuring)

         //(1)数组的解构赋值

         let [a,b,c]=[1,2,3];//模式匹配，只要等号两边的模式相同，左边的变量就会被赋予对应的值。

         //eg:
         let [foo,[[bar],baz]]=[1,[[2],3]];
         console.log(foo);//
         console.log(bar);//
         console.log(baz);//

         let[,,third]=['foo','bar','baz'];
         console.log(third);//baz

         let [x,,y]=[1,2,3];
         console.log(x);//
         console.log(y);//

         let [head,...tail]=[1,2,3,4];
         console.log(head);//
         console.log(tail);//[2,3,4]

         //如果解析不成功，变量的值就等于undefined。
         //将剩余数组赋值给一个变量，下面例子中的y解析不成功，所以是undefined，剩余元素赋值给z，因此是一个空的数组。
         let[x,y,...z]=['a'];
         console.log(x);//a
         console.log(y);//undefined
         console.log(z);//[]

         //注意：如果剩余元素右侧有一个逗号，会抛出错误的异常，因此剩余元素必须是数组的最后一个元素。
         var [a,...b,]=[1,2,3];
         console.log(b);//报错：es6.html:285 Uncaught SyntaxError: Rest element must be last element

         //如果等号的右边不是数组（或者严格地说，不是可遍历的结构，参见《Iterator》一章），那么将会报错。
         // 报错
             let [foo] = 1;
             let [foo] = false;
             let [foo] = NaN;
             let [foo] = undefined;
             let [foo] = null;
             let [foo] = {}

         //解构赋值指定默认值
         //注意：ES6内部使用严格相等运算符(===)，判断一个位置是否有值，所以，如果一个数组成员不严格等于undefined，默认值是不会生效的。

         let [x=1]=[];
         console.log(x);//

         let[x=2]=[1];
         console.log(x);//

         //以上例子说明，但右边对应数组有相应的元素的时，左边的默认值就会失效，只有当右边没有相应位置的元素时，左边默认值才会生效。

         //如果默认值是一个表达式，那么这个表达式是惰性求值的，即只有在用到的时候，才会求值。
         function f(){
             console.log('aaa');
         }

         let[x=f()]=[1];//因为x可以取到值，所以上面的f函数不会执行，上面的等价于下面的代码。

           let x;
           if([1][0]===undefined){
               x=f();
           }else{
               x=[1][0];
           }

           // 注意：  [1] 是只含元素 1 的数组
77                 // [0] 是取数组的第 0 个元素
78                 // [1][0] 的结果就是 1
79                 // [1][0] === undefined 只是个条件判断而已，即 1 === undefined

         //默认值可以引用解构赋值的其他变量，但该变量必须已经声明。

         let [x = 1, y = x] = [];     // x=1; y=1
         let [x = 1, y = x] = [2];    // x=2; y=2
         let [x = 1, y = x] = [1, 2]; // x=1; y=2
         let [x = y, y = 1] = [];     // ReferenceError

         // 上面最后一个表达式之所以会报错，是因为x用到默认值y时，y还没有声明。