數組的解構賦值
基本用法ES6允許按照一定模式，從數組和對象中提取值，對變量進行賦值，這被稱爲解構（Destructuring）。以前，爲變量賦值，只能直接指定值。
//ES5
var a=1;
var b=2;
var c=3;
ES6允許寫成下面這樣。
var [a,b,c]=[1,2,3];
console.log(a); //1
console.log(b); //2
console.log(c); //3
上面代碼表示，可以從數組中提取值，按照對應位置，對變量賦值。
本質上，這種寫法屬於“模式匹配”，只要等號兩邊的模式相同，左邊的變量就會被賦予對應的值。下面是一些使用嵌套數組進行解構的例子。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>demo</title>
<script src="js/traceur.js"></script>
<script src="js/bootstrap.js"></script>
<script type="text/traceur">
let [foo,[[bar],baz]]=[1,[[2],3]];
console.log(foo); //1
console.log(bar); //2
console.log(baz); //3
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>demo</title>
<script src="js/traceur.js"></script>
<script src="js/bootstrap.js"></script>
<script type="text/traceur">
let [,,third]=["foo","bar","baz"];
console.log(third); //baz
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>demo</title>
<script src="js/traceur.js"></script>
<script src="js/bootstrap.js"></script>
<script type="text/traceur">
let [x,,y]=[1,2,3];
console.log(x); //1
console.log(y); //3
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>demo</title>
<script src="js/traceur.js"></script>
<script src="js/bootstrap.js"></script>
<script type="text/traceur">
let [head,...tail]=[1,2,3,4];
console.log(head); //1
console.log(tail); //[2, 3, 4]
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>demo</title>
<script src="js/traceur.js"></script>
<script src="js/bootstrap.js"></script>
<script type="text/traceur">
let [x,y,...z]=['a'];
console.log(x); //a
console.log(y); //undefined
console.log(z); //[]
</script>
</head>
<body>
</body>
</html>
如果解構不成功，變量的值就等於†‡ˆ‹‡†undefined 。
var [foo]=[];
var [bar,foo]=[1];
以上兩種情況都屬於解構不成功，ˆ‘‘ foo的值都會等於undefined†‡ˆ‹‡† 。
另一種情況是不完全解構，即等號左邊的模式，只匹配一部分的等號右邊的數組。這種情況下，解構依然可以成功。
let [x,y]=[1,2,3];
console.log(x); //1
console.log(y); //2
let [a,[b],c]=[1,[2,3],4];
console.log(a); //1
console.log(b); //2
console.log(c); //4
上面兩個例子，都屬於不完全解構，但是可以成功。
如果等號的右邊不是數組（或者嚴格地說，不是可遍歷的結構），那麼將會報錯。
//報錯
let [foo]=1;
let [foo]=false;
let [foo]=NaN;
let [foo]=undefined;
let [foo]=null;
let [foo]={};
上面的表達式都會報錯，因爲等號右邊的值，要麼轉爲對象以後不具備Iterator接口（前五個表達式），要麼本身就不具備Iterator接口（最後一個表達式）。
解構賦值不僅適用於var命令，也適用於let和const命令。
var [v1,v2,...vn]=array;
let [v1,v2,...vn]=array;
const [v1,v2,...vn]=array;
對於Set結構，也可以使用數組的解構賦值。
let [x,y,z]=new Set(["a","b","c"]);
console.log(x); //a
console.log(y); //b
console.log(z); //c
事實上，只要某種數據結構具有Iterator接口，都可以採用數組形式的解構賦值。
function* fibs(){
var a=0;
var b=1;
while (true){
yield a;
[a,b]=[b,a+b];
}
}
var [first,second,third,fourth,fifth,sixth]=fibs();
console.log(sixth); //5
上面代碼中， fibs是一個Generator函數，原生具有Iterator接口。解構賦值會依次從這個接口獲取值。
------------------------------------------------------------------------
默認值
解構賦值允許指定默認值。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>demo</title>
<script src="js/traceur.js"></script>
<script src="js/bootstrap.js"></script>
<script type="text/traceur">
var [foo=true]=[];
console.log(foo); //true
let [x,y='b']=['a'];
console.log(x); //a
console.log(y); //b
let [p,q='b']=['a',undefined];
console.log(p); //a
console.log(q); //b
</script>
</head>
<body>
</body>
</html>
注意，ES6內部使用嚴格相等運算符（=== ），判斷一個位置是否有值。所以，如果一個數組成員不嚴格等於 undefined，默認值是不會生效的。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>demo</title>
<script src="js/traceur.js"></script>
<script src="js/bootstrap.js"></script>
<script type="text/traceur">
var [x=1]=[undefined];
console.log(x); //1
var [y=1]=[null];
console.log(y); //null
</script>
</head>
<body>
</body>
</html>
上面代碼中，如果一個數組成員是null ，默認值就不會生效，因爲 null 不嚴格等於undefined 。如果默認值是一個表達式，那麼這個表達式是惰性求值的，即只有在用到的時候，纔會求值。
function f(){
console.log('aaa');
}
let [x=f()]=[1];
console.log(x); //1
上面代碼中，因爲 x 能取到值，所以函數 f 根本不會執行。上面的代碼其實等價於下面的代碼。
let x;
if([1][0]===undefined){
x=f();
}else{
x=[1][0];
}
默認值可以引用解構賦值的其他變量，但該變量必須已經聲明。
let [x=1,y=x]=[];
console.log(x); //1
console.log(y); //1
let [x=1,y=x]=[2];
console.log(x); //2
console.log(y); //2
let [x=1,y=x]=[1,2];
console.log(x); //1
console.log(y); //2
let [x=y,y=1]=[];
console.log(x); //undefined
console.log(y); //1
上面最後一個表達式x之所以是未定義，是因爲 x 用到默認值 y 時， y還沒有聲明。