ES6块级命令与解构赋值

一、let，const

let命令

块级作用域 { … } ，通过let定义的变量只在当前的花括号里能够访问

{
	var str = "hello world";
	let str1 = "sdhkaj";
	const str2 = "sdmak";
}
console.log( str ); //   输出 "hello world"
console.log( str1 ); // str1 is not defined
console.log( str2 ); // str2 is not defined

不存在变量提升
利用const和let定义的变量不可以在声明之前使用，ES5中利用var定义的变量，我们这样使用没有问题

console.log(str)  //undefined
var str = 'hsks'

而在ES6中如果这样使用会报错

console.log(str)  //ReferenceError
let str = 'hsks'

暂时性死区
只要块级作用域内存在let命令，它所声明的变量只受该域的影响，不再受外部的影响。

function bar(x=y,y=2){
	return x+y
}
bar(); //报错

因为在bar函数中，参数x等于一个未声明的变量y,这就造成了一个死区；在代码块内，在使用let声明变量之前，该变量都是不可用的。
不允许重复声明
let命令不允许在相同的作用域内，重复声明同一个变量

function fibs() {
  let a = 0;
  let a = 1;		 
}
fibs();//报错  Identifier 'a' has already been declared
function fibs(a) {
  let a ;	 
}
fibs();//报错  Identifier 'a' has already been declared

因此，不能在函数体内重新声明参数。

const命令

const命令声明一个只读的常量，一旦声明，就必须立即初始化值

const PI = 3.14；
PI = 3  //报错Assignment to constant variable.

同样的，const与let一样，只在声明所在的块级作用域起作用，不能变量提升，不能重复声明，也存在暂时性死区；
特别注意：const命令定义的常量并不是值不可改动，而是变量 指向的那个内存地址所保存的值不可改变，像布尔值、数值、字符串这些简单的数据，值就保存在指向的那个内存地址中，因此相当于常量；而像数组、对象这些复合类型数据来说，变量指向的是内存地址，而内存地址里存储的是指向数据的指针，因此这种复合型数据的值是有可能改变的；

const obj={};
obj.pro = 1; //不报错，可运行
obj = {pro: 1}; //报错

当定义一个常量对象，是可以为其添加属性值的，但如果把另一个对象赋值给常量，就会报错。
ES6声明变量的六种方法
ES5 只有两种声明变量的方法：var命令和function命令。ES6 除了添加let和const命令，另外两种声明变量的方法：import命令和class命令。所以，ES6 一共有 6 种声明变量的方法。

二、解构赋值

数组的解构赋值

let [a,b,c] = [1,2,3]；
console.log(a,b,c)// 1,2,3

上面代码表示，可以从数组中提取值，按照对应位置，对变量赋值；
本质上，这属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值；

let [ a, [b],[[c],d] ] = [1,[2],[[3],4] ];
// a=1,b=2,c=3,d=4
let [ s, ...h ] = [2,3,4,5];
//s=2,h=[3,4,5]
let [x,y,..z] = ['a'];
//x='a'; y为undefined; z=[]

如果解构不成功，变量的值为undefined；
解构赋值允许使用默认值

let [a,b=0] = [1];
//a=1,b=0
let [x, y=0] = [2,undefined];
//x=2,y=0

注意，ES6 内部使用严格相等运算符（===），判断一个位置是否有值。所以，只有当一个数组成员严格等于undefined，默认值才会生效。null不恒等于undefined；
对象解构赋值

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

对象的解构赋值与数组的有一个不同，数组的解构赋值是按顺序排列的，变量的值由它的位置决定，而对象的解构赋值属性是没有次序的，变量名与属性名必须相同，这样变量才能被赋值；

let [foo,bar,baz ] = [foo:'aaa',baz:'zzz',bar:'bbb'];
//foo='aaa',bar='bbb',baz='zzz'
let [foo,bar,baz ] = [foo:'aaa',bar:'bbb'];
//foo='aaa',bar='bbb',baz=undefined

同样的，解构赋值失败，左边的变量名在右边没有与其对应的属性名，左边的变量就等于undefined；
对象嵌套结构解构赋值

let obj = {
	p:[
		'hello',
		{
			y:'world'
		}
	]
};
let {p:[x,{y}]} = obj;
// x='hello',y='world'

在这里p是模式而不是变量，如果想得到p的值可以写成let {p,p:[x,{y}]}=obj;
对象的解构赋值也可以使用默认值

let {x,y=2}={x:3}
//x=3,y=2

与数组一样，默认值生效的条件是对象的属性值严格等于undefined；
字符串的解构赋值
字符串也可以解构赋值，这是因为字符串被转换成一个类数组的对象

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

函数参数解构赋值

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

上面代码中，函数add的参数表面上是一个数组，但在传入参数的那一刻，数组参数就被解构成变量x和y。对于函数内部的代码来说，它们能感受到的参数就是x和y。
函数参数默认值

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等于默认值。
解构赋值用途
1、交换变量的值

let x= 3;
let y = 4;
[x,y] = [y,x];

2、从函数返回多个值
函数只能返回一个值，如果要返回多个值，只能将它们放在数组或对象里返回。有了解构赋值，取出这些值就非常方便。

// 返回一个数组

function example() {
  return [1, 2, 3];
}
let [a, b, c] = example();

// 返回一个对象

function example() {
  return {
    foo: 1,
    bar: 2
  };
}
let { foo, bar } = example();

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

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

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

4、提取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]

5、输入模块的指定方法
加载模块时，往往需要指定输入哪些方法。解构赋值使得输入语句非常清晰。

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