3.1 数组的结构赋值

3.1.1基本用法

ES6允许按照一定模式从数组和对象中提取值，然后对变量进行赋值，这被称为解构（Destructuring）。
以前，为变量赋值只能直接指定值。

let a = 1；
let b = 2；
let c = 3；
ES6允许写成下面这样。
let [a,b,c] = [1,2,3];
上面的代码表示，可以从数组中提取值，按照对应位置对变量赋值。

本质上，这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。下面是一些使用嵌套数组进行解构的例子。

let [foo,[[bar],baz]] = [1,[[2],3]];
foo //1
bar //2
baz//3
let [, , third] = ["foo","bar","baz"];
third //"baz"let [x, , y] = [1,2,3];
x // 1
y // 3let [head, ...tail] = [1,2,3,4];
head // 1
tail // [2,3,4]let [x,y,...z] = ['a'];
x // "a"
y // undefined
z // []
如果解构不成功，变量的值就等于undefined。let [foo] = [];
let [bar,foo] = [1];
以上两种情况都属于解构不成功，foo的值都会等于undefined。
另一种情况是不完全解构，即等于左边的模式只匹配一部分的等号右边的数组。这种情况下，解构依然可以成功。let [x,y] = [1,2,3];
x // 1
y // 2let [a,[b],d] = [1,[2,3],4];
a // 1
b // 2
d // 4
上面两个例子都属于不完全解构，但是可以成功。
如果等号的右边不是数组（或者严格来说不是可遍历的结构，）那么将会报错
//报错
let [foo] = 1;
let [foo] = false;
let [foo] = NaN;
let [foo] = undefined;
let [foo] = null;
let [foo] = {};上面的语句都会报错，因为等号右边的值或是转为对象以后不具备Iterator接口（前五个表达式），或是本身不具备Iterator接口（最后一个表达式）。

3.1.2 默认值

解构赋值允许指定默认值。
let [foo = true] = [ ];
foo //truelet [ x,y = 'b'] = ['a']; //x = 'a', y = 'b'
let [ x,y = 'b'] = ['a',undefined]; //x = 'a', y = 'b'

ES6内部使用严格相等运算符（===）判断一个位置是否有值，所以，如果一个数组成员不严格等于undefined，默认值是不会生效的。let [x = 1] = [undefined];
x // 1let [x = 1] = [null];
x // null
上面的代码中，如果一个数组成员是null，默认值就不会生效，因为null不严格等于undefined。
如果默认值是一个表达式，那么这个表达式是堕性求值的，即只有在用到时才会求值。
function f(){
console.log('aaa');
}
let [x = f()] = [1];
上面的代码中，因为x能取到值，所以函数f根本不会执行。默认值可以引用解构赋值的其他变量，但该变量必须已经声明。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=1
let [x =y ,y=1] = []; //ReferenceError
上面最后一个表达式之所以会报错，是因为x用到默认值y时，y还没有声明。

3.2 对象的解构赋值

解构不仅可以用于数组，还可以用于对象。

let {foo,bar } = {foo:"aaa",bar:"bbb"};
foo // "aaa"
bar // "bbb"

对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值是由他的位置决定的；而对昂的属性没有次序，变量必须与属性同名才能取到正确的值。

let { bar ,foo } = { foo:'aaa',bar:"bbb" };
foo // "aaa"
bar // "bbb"let {baz} = {foo:"aaa",bar:"bbb"};
baz //undefined
上面代码的第一个例子中，等号左边的两个变量的次序与等号右边两个同名属性的次序不一致，但是对取值完全没有影响。第二个了例子的变量没有对应的同名属性，导致取不到值，最后等于undefined。
如果变量名与属性名不一致，必须写成下面这样。var {foo:baz } = {foo:'aaa',bar:'bbb'};
baz //"aaa"let obj = {first:'hello',last:'world'};
let {first:f,last:l} = obj
f // 'hello'
l // 'world'
实际上说明，对象的解构赋值是下面形式的简写
let {foo:foo,bar:bar} = {fooL"aaa",bar:"bbb"};
也就是说，对象的解构赋值的内部机制是先找到同名属性，然后再赋值给对应的变量。真正背赋值的是后者，而不是前者。
let { foo:baz } = {foo:"aaa",bar:"bbb"};
baz //"aaa"
foo //error:foo is not defined
上面的代码中，foo是匹配的模式，baz才是变量。真正被赋值的是变量baz而不是模式foo。与数组一样，解构也可以用于嵌套结构的对象。
let obj = {
p:[ 'hello',{ y:'world'}]
};let {p:[x,{y}]} = obj;
x// "hello"
y// "world"
注意，这时p是模式，不是变量，因此不会被赋值。如果p也要作为变量赋值，也可以是下面这样let obj = {
p:['hello',{y:'world}]
};
let {p,p:[x,{y}]} = obj;
x // "hello"
y // "world"
p // ["hello",{y:"world"}]下面是嵌套赋值的例子。
let obj = {};
let arr = [];
({foo:obj.prop,bar:arr[0] } = { foo:123,bar:true});
obj //{prop:123}
arr // [true]对象的解构也可以指定默认值
var {x = 3} = {};
x // 3var {x,y = 5} = {x:1};
x // 1
y // 5var {x:y = 3} = {};
y // 3var {x:y = 3} = {x:5};
y // 5默认值生效条件是，对象的属性值严格等于undefined。
var {x = 3} = {x:undefined};
x // 3
var {x = 3} = {x:null};
x //null
上面代码中，如果x属性等于null，就不严格等于undefined，导致默认值不会生效。
如果结构失败，变量的值等于undefined。
let {foo} = {bar:'baz'};
foo // undefined
如果解构模式是嵌套的对象，而且子对象所在的父属性不存在，那么将会报错。
//报错
let {foo:{bar}} = {baz:'baz};
上面的代码中，等号左边对象的foo属性对应一个子对象。该子对象的bar属性在解构时会报错。原因很简单，因为foo此时等于undefined，再取子属性就会报错，请看下面代码。
let _tmp = {baz:'baz'};
_tmp.foo,bar //报错
如果要将一个已经声明的变量用于解构赋值，必须要非常小心，
//错误的写法
let x;
{x} = {x:1}
//报错
上面代码的写法会报错，因为javaScript引擎会将{x}理解成一个代码块，从而发生语法错误。只有不将大括号写在行首，避免JavaScript将其解释为代码块，才能解决这个问题
//正确的写法
let x;
({X} = {x:1})
上面的代码将整个解构赋值语句放在一个圆括号里面，这样就可以正确执行。由于数组本质是特殊对象，因此可以对数组进行对象属性的解构。
let arr = [1,2,3];
let {0:first,[arr.length - 1]:last } = arr;
first // 1
last // 3
上面的代码对数组进行对象的解构，数组arr的0键对应的值是1，[arr.length - 1]就是2键，对应的值是3.方括号这种写法属于“属性名表达式”

3.3 字符串的解构赋值

字符串也可以解构赋值。这是因为此时字符串被转换成了一个类似数组的对象。

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

类似数组的对象都有一个length属性，因此还可以对这个属性进行解构赋值。

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

3.4 数值和布尔值的解构赋值

解构赋值时，如果等号右边是数值和布尔值，则会先转为对象。

let {toString:s} = 123;
s === Number.prototype.toString // true
let {toString:s} = true;
s === Boolean.prototype.toString // true
上面的代码中，数值和布尔值的包装对象都有toString属性，因此变量s都能取到值。

解构赋值的规则是，只要等号邮编的值不是对象或数组，就会先将其转为对象。由于undefined和null无法转为对象，所以打他们进行解构赋值时都会报错。

3.5 函数参数的解构赋值

函数的参数也可以使用解构赋值。

function add ([x,y]){
return x+y;
}
add([1,2]); // 3
上面的代码中，函数add的参数表面上是一个数组，但在传入参数的那一刻，数组参数就被解构成变量x和y。对于函数内部的代码来说，他们能感受到的参数就是x和y。
下面时另一个例子
[[1,2],[3,4]].map(([a,b]) =>a+b);
// [3,7]

函数参数的解构也可以使用默认值。

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

上面的代码中，函数move的参数是一个对象，通过对这个对象进行解构，得到变量x和y的值.如果解构失败，x和y等于默认值

3.6 用途

变量的解构赋值用途很多
交换变量的值

let x = 1;
let y = 2;[x,y] = [y,x];
上面的代码交换变量x和y的值，这样的写法不仅简洁，而且易读，语意非常清晰。

从函数返回多个值

函数只能返回一个值，如果要返回多个值，只能将他们放在数组或对象里返回，有了解构赋值，取出这些值就非常方便。
//返回一个数组
function example(){retrun [1,2,3];
}
let [a,b,c] = example();
//返回一个对象
function example(){return {foo:1,bar:2}
}
let {foo,bar } = example();

函数参数的定义
解构赋值可以方便地将一组参数与变量名对应起来。

//参数是一组有次序的值
function f([x,y,z]){...}
f([1,2,3]);//参数是一组无次序的值
function f({x,y,z}){...}
f({z:3,y:2,x:1});

提取JSON数据
解构赋值对提取JSON对象中的数据尤其有用。

let jsonData = {id:42,status:"ok"data:[867,5309]};
let {id,status,data:number} = jsonData;
console.log(id,status,number);
// 42,"ok",[867,5309]
上面的代码可以快速提取JSON数据的值。

函数参数的默认值

jQuery.ajax = function (url,{async = true,beforeSend = function (){},cache = true,complete = function(){},crossDomain = false,//...more config}){//...do stuff
};
指定参数的默认值这样就避免在函数体内部再写var foo = config.foo || 'default foo ';这样的语句

遍历Map结构

输入模块的指定方法

const {SourceMapConsumer,SourceNode} = require("source-map")