• 基本用法
  可以從數組中提取值，按照對應的位置，對變量賦值

let a=1;
let b=2;
let c=3;
//可以寫成下面這樣
[a,b,c]=[1,2,3]

• 嵌套數組進行結構

let [a,[[b],c]]=[1,[[2],3]]
// a=1,b=2,c=3
let [,,c]=[1,2,3]
//c=3
let [a,,c]=[1,2,3]
//a=1 c=3
let [a,...b]=[1,2,3]
//a=1  b=[2,3]
let [a,b,c]=[1,2]
//a=1 b=2 c=undefined

• 不完全解構
  即等號左邊的模式只匹配一部分等號右邊的數組

let [x,y]=[1,2,3]
//x=1 y=2
let [x,[y],z]=[1,[2,3],4]
//x=1 y=2 z=4

• 只要具有Iterator接口，都可以采用數組形式的解構賦值

let [x,y,z]=new Set([1,2,3]);
//x=1 y=2 z=3

function* getA(){//Generator具有iterator接口
let a=0;
let b=1;
while(true){
  yield a;
  [a,b]=[b,b+1]
}
}
let [one,two,three]=getA();
//one=0 two=1 three=2

• 默認賦值
  當數組成員不嚴格等于undefined,默認值不會生效

let [a=1,b,c]=[,2,3]
//a=1,b=2,c=3
let [a=1]=[null]
//a=null
let [a=1]=[undefined]
//a=undefined

• 對象的解構賦值

let {name ,age}={name:'wang',age:18}
//name='wang' age=18
//對象的屬性沒有次序，變量名與屬性同名才能取到正確的值
let{name,age}={age:18,name:'wang'}
//name='wang' age=18
//變量名與屬性名不同的情況
var{name:n}={name:'wang',age:18}
//n='wang'

• 對于let ,const 來說解構不能重新聲明

let foo;
let {foo}={foo:1} //報錯，重復聲明

//正確的方式
let foo;
({foo}={foo:1}) //圓括號是必須的，因為解析器會默認將起首的大括號理解成一個代碼塊

• 字符串的解構賦值
  字符串也可以解構賦值，因為此時，字符串被換成一個類似的數組的對象

const [a,b,c,d,e]='hello'
//a='h'  b='e' c='l' d='l' e='o'

• 數組對象的length屬性也可以進行結構

let {length:len}='hello'
// len= 5

• 函數參數的解構賦值

function add([x,y]){
  return x+y;
}
add([1,2])

[[1,2],[3,4]].map(([a,b])=>a+b);
//[3,7]

//默認值
function move({x, y} = { x: 0, y: 0 }) {
  return [x, y];
}
move({x: 3, y: 8}); // [3, 8]

• 用途

//交換變量
let x=1;
let y=2;
[x,y]=[y,x]

//從函數返回多個值
function getArray(){
return [1,2,3]
}
let [a,b,c]=getArray()
//a=1,b=2,c=3
function getObject(){
return {x:1,y:2}
}
let {x,y}=getOject()
//x=1 y=2

//參數是一組有次序的值
function f([a,b,c]){}
//參數是一組無序的值
function f({c,a,b}){}

//提取json數據
let jsonData = {
  id: 42,
  status: "OK",
  data: [867, 5309]
}
let { id, status, data: number } = jsonData;

//遍歷map
for(let [key,value] of map){ }
// 獲取鍵名
for (let [key] of map) {}
// 獲取鍵值
for (let [,value] of map) {}

//導入模塊對應的方法
const { SourceMapConsumer, SourceNode } = require("source-map")