1.let
（1）用于声明变量。其用法类似于var，但是所声明的变量只在let命令所在的代码块内有效。
最常见的就是for循环那个例子
var a=[];
for(var i=0;i<10;i++){
a[i]=function(){
console.log(i);
}
}
a[6]();//10
变量i是var声明的，在全局范围内有效，所以全局只有一个变量i。每一次循环，变量i的值都会发生改变，而循环内，被赋给数组a的函数内部的console.log(i)中的i指向全局的i。也就是说，所有数组a的成员中的i指向的都是同一个i，导致运行时输出的是最后一轮的i值，也就是10
var a=[];
for(let i=0;i<10;i++){
a[i]=function(){
console.log(i);
};
}
a[6]();//6
变量i是let声明的，当前的i只在本轮循环有效。所以每次循环的i其实都是一个新变量，于是最后输出的是6.
疑问：如果每一轮的变量i都是重新声明的，那它怎么知道上一轮循环的值？
解答：这是因为javascript引擎内部会记住上一轮循环的值，初始化本轮的变量i时，就在上一轮循环的基础上进行计算。
特别之处：设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域。
for(let i=0;i<3;i++){
let i="abc";
console.log(i);
}
//abc
//abc
//abc
函数内部的变量i与循环变量i不在同一个作用域，而是有各自单独的作用域；
（2）不存在变量提升
var命令会发生“变量提升”现象，即变量可以在声明之前使用，值为undefined。
let命令改变了语法行为，他所声明的变量一定要在声明后使用，否则会报错
console.log(foo);//输出undefined；
var foo=2;
console.log(foo);//报错ReferenceError；Uncaught ReferenceError: foo is not defined
let foo=2;
（3）暂时性死区
只要块级作用域内存在let命令，它所声明的变量就绑定在这个区域，不受外部的影响；
var tmp=123;
if(true){
tmp="abc";
let tmp;
console.log(tmp);//报错ReferenceError；Uncaught ReferenceError: tmp is not defined
}
上面的代码存在全局变量tmp，但是块级作用域内部又声明了一个局部变量tmp，后者绑定这个区域，不再受外部的影响
ES6明确规定，如果区块中存在let和const命令，则这个区块对这些命令声明的变量从一开始就形成封闭作用域。只要在声名之前使用变量，就会报错；
“暂时性死区”也意味着typeof不再是一个百分百安全的操作，在没有let之前，typeof是百分百安全的，永远不会报错；
typeof x;//报错ReferenceError；Uncaught ReferenceError: foo is not defined
let x;
（4）不允许重复声明
let不允许在相同作用域内重复声明同一个变量。
//报错
function(){
let a=10;
var a=1;
}
2.const
（1）声明一个只读函数。一旦声明，常量的值就不能改变
（2）const一旦声明常量，就必须立即初始化；
本质：const实际上保证的并不是变量的值不得改动，而是变量指向的那个内存地址不能改动。
对于简单的基本类型，值就保存在变量指向的内存地址中，因此等同于一个常量。但对于复合类型的数据（对象和数组）而言，变量指向的内存地址保存的只是一个指针，const只能保证这个指针是固定的，至于它指向的数据类型是不是可变不得而知。
const foo={}；
foo.prop=123;
console.log(foo.prop);//123
console.log(foo);// Object {prop: 123}
//报错
foo={};/Uncaught TypeError: Assignment to constant variable.
对象冻结：Object.freeze方法
const foo=Object.freeze({});
foo.prop=123;//常规模式下不起作用，严格模式下报错
console.log(foo.prop);//undefined
对象彻底冻结函数
var constentize=(obj)=>{
Object.freeze(obj);
Object.keys(obj).forEach((key,i)=>{
if(typeof obj[key]==="object"){
contentize(obj[key]);
}
})
}
Object.keys(obj)
参数：要返回其枚举自身属性的对象
返回值：一个表示给定对象的所有可枚举属性的字符串数组。
3.块级作用域详解
（1）块级作用域的作用
ES5只有全局作用域和函数作用域，没有块级作用域，导致问题为以下两点
a.内层变量覆盖外层变量
var tmp=new Data();
function foo(){
console.log(tmp);
if(false){
var tmp="hello world";
}
}
foo();//undefined;
代码块的原意是，if代码块外部使用外层tmp变量，内层使用内层的tmp变量，但是函数执行后，因为变量提升，内部的tmp覆盖了外部的tmp；所以undefined；
b.用来计数的循环变量变成全局变量
var s="hello"
for(var i=0;i<s.length;i++){
console.log(s[i]);
}
console.log(i);//5
i循环结束后并没有消失，而是泄露成全局变量；
（2）ES6浏览器
如以下代码`
function f(){console.log("I'm outside")};
(function (){
if(false){
function f(){console.log("I'm inside")}
}
f();
}()
)
在ES5中运行
function f(){console.log("I'm outside")};
(function (){
function f(){console.log("I'm inside")}
if(false){
}
f();
}()
)
输出为I'm inside
因为if内声明的函数被提升到函数头部
在ES6浏览器中运行
行为方式：1.允许在块级作用域内声明函数；
2.函数声明类似于 var，即会提升到全局作用域或函数作用域的头部
3.函数声明会提升到其所在的块级作用域的头部。
function f(){console.log("I'm outside")};
(function (){
var f=undefined;
if(false){
function f(){console.log("I'm inside")}
}
f();
}()
)
//报错；Uncaught TypeError: f is not a function；
因此应避免在块级作用域内声明函数，如果确实需要，应写成函数表达式的形式；
function f(){console.log("I'm outside")};
(function (){
if(false){
let f=function (){console.log("I'm inside")}
}
f();
}()
)
//输出I'm outside；prefect
（3）do表达式
本质上，块级作用域是一个语句，将多个操作封装在一起，没有返回值
let x=do{
let t=2;
t*t+1;
}
x会得到整个块级作用域的返回值。
不知道为什么报错显示 Unexpected token do；
