块级作用域

es5只需全局作用域和函数作用域，没有块级作用域，这带来了许多不合理的场景。

第一种场景：内层变量可能会掩盖外层变量

var test = "outside";

function f () {
    console.log(test);
    if (false) {
        var test = "inside";
    }
}

f(); // undefined

涌现这类效果的原因是变量提拔，致使内层的test掩盖了外层的test

第二种场景：用来计数的轮回变量泄漏为全局变量

var str = "hello";

for(var i = 0; i < str.length; i++){
    console.log(s[i]);
}

console.log(i);  // 5

let敕令

1. let声明的变量只在其代码块内有用，var没有块作用域

2. 不存在变量提拔

3. 暂时性死区（TDZ）：es6明确划定，假如地区块中存在let和const敕令，则这个区块对这些敕令声明的变量从一最先就构成封闭性作用域。只需在声明之前挪用这些变量就会报错。

{
    //TDZ最先
    test = "test";   //ReferenceError
    console.log(test);   //ReferenceError
    
    let test;    //TDZ完毕
    console.log(test);   //undefined
    
    
    //比较隐藏的TDZ
    function testFn (x=y, y=2) {
        return[x,y];
    }
    
    testFn();   //报错
}

1. 不许可反复声明：不许可在同一个作用域内反复声明同一个变量

//报错
{
    let test = 1;
    var test = 2;
}

//报错
{
    let test = 1;
    let test = 2;
}

const

const用来声明常量

1. 一旦声明，其值就不能转变

2. 必需马上初始化，即马上赋值

3. 不存在常量提拔，同let一样存在暂时性死区

4. 同let一样不可反复声明

5. 作用域：只在当前代码块有用

6. const敕令只能保证常量名指向数据的地点稳定，然则不能保证该地点的数据稳定，如

const obj = {};
obj.prop = 'test';

console.log(obj.prop);   //'test'

obj = {};   //typeError: "obj" is read-only

跨模块常量

可运用export使常量跨模块

//constant.js
export const A = 1;
export const A = 2;
export const A = 3;

//test1模块
import * as constants from './constans';
console.log(constants.A); // 1
console.log(constants.B); // 2

//test1模块
import {A, B} from './constans';
console.log(constants.A); // 1
console.log(constants.B); // 2

全局对象的属性

在es5中，全局对象（window/global）的属性与全局变量是等价，在es6中划定，let、const、class敕令生声明的全局变量不属于全局对象的属性。如

var a = 1;
b = 2;

console.log(window.a);  // 1
console.log(window.b);  // 2

let c = 3;
console.log(window.c); // undefined

es6声明变量的要领

es5只需两种声明变量的要领：var、function敕令

es6一共有六种：var、function、let、const、import、class敕令

变量的解构赋值

es6许可根据肯定的情势，从数组和对象中提取，根据位置的对应关联对变量赋值，这被称为解构。本质上，这类写法属于情势婚配。

1. 数组的解构赋值

 //- 解构胜利：等号双方情势雷同
var [a, b, c] = [1, 2, 3];
console.log(a, b, c); // 1 2 3

let [l, [[m], n]] = [1, [[2], 3]];
console.log(l, m, n); // 1 2 3

let [x, , y] = [1, 2, 3];
console.log(x, y); // 1 3

let [o, ...p] = [1, 2, 3, 4];
console.log(o); // 1 
console.log(p); // [2, 3, 4] 

//- 不完全解构： 等号左侧的情势只婚配等号右侧数组的一部分
let [x, y] = [1, 2, 3]; 
console.log(x); //1
console.log(y); //2

let [x, [y], z] = [1, [2, 3], 4]; 
console.log(x); //1
console.log(y); //2
console.log(z); //4

//-解构不胜利。假如解构不胜利，变量的值就即是undefined
let [a, b, c] = [1];
console.log(a); //1
console.log(y); //undefined
console.log(z); //undefined

注重，假如等号的右侧不是数组，严格来说不是遍历构造，那末将会报错

//-报错
let [a] = 1;
let [b] = false;
let [c] = NaN;
let [d]  =undefined;
let [e] = null;
let [f] = {};

前5种转为对象后不具有iterator接口，末了一个自身就不具有iterator接口

事实上，只需某种数据接口具有iterator接口，都可以运用数组情势的解构赋值

默认值

来日诰日再写

1. 对象的解构赋值

2. 字符串的解构赋值

3. 数值和布尔值的解构赋值

4. 函数参数的构造赋值