1 //1.首先，什麼是解構賦值？
 2 //在ES6中，允許按照一定的模式從數組和對象中提取值，然後對變數進行賦值，這個被稱為解構賦值，舉個例子：
 3 let a = 1;
 4 let b = 2;     //普通的變數聲明
 5 let [a,b] = [1,2];   //利用解構賦值進行的變數聲明（該方法為「模式匹配」）
 6 //至此我想大家都應該知道解構賦值的大概意思了吧！
 7 //利用模式匹配的方法對數組進行解構：
 8 let [a,[b,c]] = [1,[2,3]]; //簡單理解就是對應變數對應的值
 9 ​
10 ​
11 //2.模式匹配的三種情況：解構成功，解構不成功，不完全解構,以及模式匹配的條件。如下：
12 //(1)解構成功就是對應都有值，這個就不再多說
13 //(2)解構不成功，則變數的值就是undefined，例如：
14 let [f] = [];
15 let [a,f] =[1];    //這兩個都是解構不成功，對應的f就是undefined 
16 //(3)不完全解構，意思應該是數值較多，變數少的情況。例如：
17 let [a,b,c] = [1,2,3,4];  //這裡右邊有四個數值，左邊有三個變數，那就是從左向右對應賦值，解構可以成功，但是不完全。
18 //(4)模式匹配的條件：如果等號右邊不是可遍歷的解構，那麼將會報錯。例如：
19 let [f] = 2;
20 let [f] = false;    
21 let f = NaN;        //這幾個都會報錯，原因就是等號右邊的值轉為對象後不具備Iterator介面，或者就是本身就沒有這個介面
22 let f = undefined;   
23 //只要有Iterator介面，或者是Generator函數，也都可以進行解構賦值，例如：
24 function *fibs(){
25     let a = 0;
26     let b = 1;
27     while(true){
28         yield a;
29         [a,b] = [b,a+b];
30     }
31 }
32 let [a,b,c,d,e,f] = fibs(); //f = 5;
33 //當然Iterator，Generator是什麼？大家可以先搜索一下了解一下，在之後我會就這部分單獨進行學習和複習，以及做筆記。
34 ​
35 ​
36 //3.默認值
37 //(1)解構賦值可以做默認值，那麼默認值是幹什麼的？是什麼？看以下例子你就知道了：
38 let [f = 1] = [];   //f的值是1
39 let [x = 1] = [undefined]   // x的值是1
40 let [x = 1] = [null]   //x的值是null，這種情況和上面的不同，為什麼呢？
41 //大家看完上面的例子為什麼最後一個是null？看第(2)點。
42 //(2)注意一個默認值規則：ES6內部的默認值是先進行===判斷，然後再讓默認值生效的。
43 let [x = 1] = [null]  //當執行這一句，會先判斷等號右邊括弧內是否是undefined，此時右邊是null與undefined不一樣，所以默認值不會生效，結果就是null
44 let [x = 1] = [];    //等號右邊是空，空也就是undefined，所以默認值可以生效，所以x=1成立
45 //(3)默認值的方式
46 //默認值可以是變數：
47 let [x =1,y = x]= [];  // x=1;y=1;
48 let []x = 1,y=x] =[2]; //x = 2,y = 2; 先進行===比較，如果右邊有值，先賦值，如果沒了，取默認值
49 //默認值可以表達式，而表達式是惰性的，在用時才會執行：
50 function(){
51     console.log('aaa');
52 }
53 let [x = f()] = [1];   //在該程式碼中，等號右邊數組裡面有值，則x可以取到值，因此不需要默認值，那麼f()這個表達式根本不會執行。
54 ​
55 //注意：數組的模式是成員，而不是成員的值，兩回事，在最後的圓括弧內會提及

 1 //1.對象解構的規則（與數組解構的區別）
 2 //(1)對象解構與數組解構不同，對象解構是匹配屬性名的，而不看順序:
 3 let {b,f} = {f:"f",b:"b"};  //得到的結果b為b，f為f
 4 //(2)對象解構是屬性找不到匹配值會得到undefined
 5 //(3)對象的匹配模式，不同變數名的解構賦值操作：
 6 let{匹配已有屬性名：真正想要改變值的屬性名} = {匹配已有的屬性名：對應的屬性值}; 
 7 let{f:f} = {f:"fff"}; //對象的匹配模式是等號左邊的f屬性的值是個f變數，這樣匹配到的f屬性的值才是fff
 8 let{f:a} = {f:"fff"}; //對象中含有屬性a，但是等號右邊沒有屬性a，此時怎麼對屬性a賦值呢？利用f屬性：對應屬性就可以讓a得到fff
 9 let{foo:bar} = {foo:"barbarbar"}  //結果就讓bar得到了barbarbar字元串
10 //在上面的程式碼中，foo與f是匹配的模式，f，a，bar才是變數，才是真正被賦值的，而不是匹配模式
11 //(4)匹配模式的嵌套理解：
12 var demo = {
13     a:{
14         b:{
15             c=1
16         }
17     }
18 }
19 var {a,a:{b},a:{b:{c}}} = demo;  //c:1,b為{c=1},a為{b:obj},該匹配等號左邊的a相當於 a:a的形式
20 ​
21 ​
22 //2.對象解構的默認值
23 //對象解構也可以有默認值，默認值的條件仍舊是等號右邊對象屬性判斷為undefined
24 var {x = 3} ={}  //x = 3
25 var {x:y = 3}={} //匹配模式x為匹配名字，對應得還是y得值改變，此時等號右邊為undefined，y取默認值
26 var {x:x = 3} = {x:null}  //仍舊為null
27 ​
28 ​
29 //3.對象解構與數組解構
30 //因為數組得本質也是對象，因此可以讓對象與數組相互使用:
31 let arr = [1,2,3];
32 let{0:a,1:b,2:c} = arr;  //a=1,b=2,c=3 此時就很類似偽數組
33 ​

 1 //字元串也可以解構賦值，此時就轉化為一個偽數組形式
 2 const [a,b,c]="big";   //a為b，b為i，c為g
 3 //偽數組（對象）也有一個length屬性
 4 let {length:len} = "hello";  //len = 5;
 5 //創建一個偽數組對象類似於下列：
 6 var ar={
 7     0:'1',
 8     1:'2',
 9     length:2
10 }

1 //等號右邊是數值或者布爾值，則會先轉化為對象，而undefined，或者null無法轉化為對象，因此肯定會報錯：
2 let {toString:a} = 1;
3 let {toString:a} = true;
4 //a都可以取到一個Number，一個Boolean ， 因為數值和布爾值對象裡面都含有toString方法，含有就可以用

 1 //函數得參數可以解構賦值
 2 function add([x,y]){
 3     return x+y;
 4 }
 5 add([1,2])   //3,其中[1,2]與形參[x,y]就相當於一個解構賦值 [x,y]=[1,2];
 6 //函數參數解構可以有默認值，下面介紹兩種不同形式
 7 function x({x=0,y=0}={}){
 8     return [x,y];
 9 }
10 x({x:1,y:2});   //[1,2]   第一種參數
11 x({});    //[0,0]  第二種參數
12 x();    //[0,0]   第三種參數
13 //以上為第一種情況，當參數種等號右邊傳進去得值為第一種得時候，判斷對象為非undefined則執行賦值，當傳入的是第二種參數時，判斷對象為undefined，此時就會有默認值x = 0， y = 0；
14 function({x,y}={x:0,y:0}){
15     return [x,y];
16 }
17 x({x:3,y:8});   //[3,8] 
18 x({})  //[undefined，undefined];  當傳入為undefined，
19 //綜上所屬，實際上時函數參數來得到默認值，而不是變數x，y。當有undefined時會觸發默認值

 1 //1.交換變數的值
 2 let x = 1;
 3 let y = 2;
 4 [x,y] = [y,x];
 5 //2.從函數返回多值
 6 function sss(){
 7     return [1,2,3];
 8 }
 9 let [a,b,c] =sss();  //當然也可以返回一個對象，
10 //3.函數參數定義，這個就不多說了
11 //4.提取JSON數據
12 let jsonDate = {
13     id:1,
14     status:'OK',
15     data:[888,888]
16 }
17 let {id,status,number} = jsonData;
18 //5.函數參數的默認值
19 //6.遍歷Map解構
20 //任何部署了Iterator介面的對象都可以用for...of循環遍歷。Map解構原生支援Iterator介面，配和變數值取值就很方便
21 var map = new Map();
22 map.set('a','b');
23 ​
24 for(let [key,value] of map){
25     console.log(key + "is" + value);
26 }
27 //該部分如果涉及到那些不了解的部分可以先自行查閱，後面我也會一一學習map與Iter介面。
28 //7.輸入模組的指定方法
29 const{SourceMapConsumer,SourceNode} = require("source-map");
30 //以上基本都是有數組，值傳遞的點，這些點注意可以使用解構賦值，會更加的方便，在學習複習後面的知識的時候，都會穿插舉例子，越學越明白

 1 //這裡就涉及到解構賦值的問題了，解構賦值雖然很方便，但是解析起來並不是很容易，對於具體的種類需要遇到等號的時候才可以得到答案，出現[]，{}都可以理解，但是出現了()又怎麼辦呢？ES6的解釋就是，那就別用()了,哈哈，有問題，就跳過問題，不就沒問題了？我直呼好傢夥！當然肯定盡量不使用()。
 2 //1.不能使用()的情況
 3 //(1)變數的聲明
 4 let [(a)] = [1];   //肯定報錯
 5 let {x:(c)} = {}   //報錯
 6 let {(x):c} = {}   //報錯
 7 let (o:({p:p}))={o:{p:2}};   //報錯
 8 //聲明變數絕對不可以用()
 9 //(2)函數的參數，也屬於變數聲明肯定不可以加()，這裡就不舉例子了，把上面的等號左邊的變數或者對象直接放到函數小括弧內就是了
10 //(3)賦值語句
11 ({p:a}) = {p:42};  //報錯
12 ({p:(d)}) = [5];  //報錯
13 [({p:a}),{x:c}] = [{},{}];  //報錯
14 //把程式碼模式放到括弧里，把一部分放到括弧里都會導致報錯
15 ​
16 //2.可以使用的情況
17 //只有一種賦值語句非模式部分可以使用()
18 [(b)] = [3];  //第一種數組
19 ({p:(d)}) ={})   //非模式部分可以使用括弧
20 //首先，可以使用的原因，都是賦值語句，不是聲明語句，括弧里都不屬於模式的一部分，第一種數組的模式是b值對應的數組的第一個成員，而括弧里的是數組第一個成員對應的值。