• 基本用法
  可以从数组中提取值，按照对应的位置，对变量赋值

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")