1.数组的解构赋值
我们晓得之前我们给一个变量赋值要如许以下：
let a = 1;
let b = 2;
let c = 3;然则ES6出来以后，我们能够如许：
let [a, b, c] = [1, 2, 3]以上就是从数组中提起值，一一对应赋值，a、b、c离别为1、2、3
let [aa, [[bb], cc]] = [1, [[2], 3]]aa,bb,cc离别对应1,2,3
let [,,d] = [10, 20, 30];
console.log(d);d的值为30
let [e, ...f] = [1, 2, 3, 4, 5];e为1, f为[2,3,4,5]
let [x, y, ...z] = [1];x为1，y为undefined，z为[]，假如没有对应值会即是undefined
解构赋值也许可默许值， 以下：
let [ x = '默许值'] = [];x的值为默许值
let [ a = 123 ] = [ undefined ];
let [ b = 321 ] = [ null ];a的值为123，b的值为321，因为ES6中是严厉遵照（===），所以只有当数组对应的值为undefined的时刻，才即是默许值
默许值能够援用解构赋值的其他变量，然则这个变量必需得声明过的，以下：
let [ a = 0, b = a] = [];这里a、b离别为0,0
然则假如这个变量没有声明，就会报错，以下：
let [ a = b, b = 1] = [];这里就会报错：Uncaught ReferenceError: b is not defined
2.对象的解构赋值
let { a, b } = { a: 1, b: 2 };a,b的值为1,2
对象解构赋值能够无需根据递次一一对应，然则括号双方的变量称号和属性称号要雷同，才取到准确值
let { a, b } = { a: 1, c : 2};a为1，b为undefined，这里b在右侧括号中没有对应的属性值与其对应，所以此时b为undefined
假如变量名和属性名不一样，则要根据以下写：
let { aa: fa, bb: fb } = { aa: 1, bb: 2 };fa为1，fb为2
这里能够申明，对象解构赋值实际上是以下的简写：
let { aa: aa, bb: bb } = { aa: 1, bb: 2}也就是说，对象的解构赋值的内部机制，是先找到同名属性，然后再赋给对应的变量。真正被赋值的是后者，而不是前者。
let { aa: fa } = { aa: 1 }
//fa为 1
//aa为 Uncaught ReferenceError: aa is not defined这里就申清楚明了，fa是真正被赋值的,此时的aa是形式而不是变量，假如你要让aa为变量，则以下：
{
let { aa: fa, aa } = { aa: 1 };
// aa 为 1
// fa 为 1
}此时aa为1，bb为1,此时aa就是变量了
固然对象也能够多层嵌套以下：
{
let obj = {
p: [1, { y: 2 }]
}
let { p: [x, { y }]} = obj;
console.log(x); // 1
console.log(y); // 2
}
{
let obj = {};
let arr = [];
({a: obj.name, b: arr[0] } = { a: 321, b: 123});
console.log(obj); // { name: 321 }
console.log(arr); // [123]
}对象解构默许值：
{
let { x = 1 } = {};
console.log(x); //1
}
{
let { x : y = 4 } = {};
console.log(y); //4
}
{
let { x : y = 4 } = { x: 5};
console.log(y); //5
}
默许属性见效前提必需是对象的属性严厉即是undefined，假如是null就不会见效，以下：
{
let { x = 1 } = { x : null};
console.log(x); //null
}已声明的变量解构赋值：
{
let x;
({ x } = { x : 1 });
console.log(1); // 1
}得要加个小括号才够，不然会报错；
数组对应对象属性的解构：
{
let arr = [1, 2, 3];
let { 0 : one, [arr.length-1] : three } = arr;
console.log(one); // 1
console.log(three); // 3
}3.字符串的解构赋值
字符串也能够解构赋值，因为字符串能够转换成一个相似数组的对象
{
let [a, b, c, d] = 'hero';
console.log(a); //h
console.log(b); //e
console.log(c); //r
console.log(d); //o
}相似数组的对象都有一个length属性，能够对这个属性解构赋值
{
let { length: len } = 'hero';
console.log(len); // 4
}4.数值和布尔值的解构赋值
解构赋值时，假如等号右侧是数值或许布尔值时，则会先转换成对象
{
let { toString: s } = 123;
console.log(s === Number.prototype.toString); //true
}
{
let { toString: s } = true;
console.log(s === Boolean.prototype.toString); //true
}解构赋值的划定规矩：假如等号右侧的值不是对象或许数组则会先转为对象，因为undefined和null没法转为对象，所以没法对它们举行解构赋值，会报错，以下：
{
let { props: x} = undefined; //报错
let { props: y} = null; //报错
}5.函数参数的解构赋值
{
const arr = [[1,2],[3,4]].map(([a, b])=> a+b);
console.log(arr); //[3,7]
}函数参数默许值：
function func({x = 0, y = 0} = {}) {
return [x, y];
}
console.log(func({x:5,y:6})); //[5,6]
console.log(func({x:5})); //[5,0]
console.log(func({})); //[0, 0]
console.log(func()); //[0, 0]假如根据以下定义就差别了，以下：
function fn({x, y} = { x: 1, y: 2}) {
return [x, y];
}
console.log(fn({ x: 11, y: 22})); // [11, 22]
console.log(fn({ x: 11 })); // [11, undefined]
console.log(fn({})); // [undefined, undefined]
console.log(fn()); // [1, 2]undefined会触发函数参数的默许值，以下：
{
const a = [1, undefined, 3].map((x = 'noundefine') => x);
console.log(a); //[1, "noundefine", 3]
}6.圆括号题目
圆括号只能一种状况才运用：赋值语句的非形式部份，能够运用圆括号
[(b)] = [3]; // 准确
({ p: (d) } = {}); // 准确
[(parseInt.prop)] = [3]; // 准确上面三行语句都能够准确实行，因为起首它们都是赋值语句，而不是声明语句；其次它们的圆括号都不属于形式的一部份。第一行语句中，形式是取数组的第一个成员，跟圆括号无关；第二行语句中，形式是p，而不是d；第三行语句与第一行语句的性子一致。
本文参考链接：http://es6.ruanyifeng.com/#do…
主如果看了阮一峰先生的文章，本身整理了一下，供后期本身看笔记用的
