ES6中let和const

let

1.let声明的变量不会挂在window中，不会造成全局变量的污染
2.新增了一个块级作用域{}，以前只有函数作用域，全局作用域
3.let是不允许重复声明
4.let不会有声明提前（只是人为看到的效果，实际上是有声明提前，提前临时性的死区中：Cannot access ‘num’ before

 1.   {
      let a = 10;
      var b = 1;
   }
  console.log(a);    //a is not defined;
  console.log(b);

let   只在命令代码所在的代码块内有效。

for(let i=0;i<10;i++){
        console.log(i);
    }
  console.log(i);  //i is not defined;
for  循环适合使用let命令

var a=[];
    for(var i=0;i<10;i++){
      console.log(i);
      a[i]=function () {
        console.log(i);
      };
  }
    a[1]();   // 10

因为是用var定义的，i是全局的每次循环i都会发生变化。里面的i指向的是全局的i，导致输出的是最后一轮的i值

 var a=[];
    for(let i=0;i<10;i++){
        console.log(i);
        a[i]=function () {
            console.log(i);
        };
    }
    a[9]();

用let声明 i只在本轮循环有效，每一轮循环都是新的标量。javascript引擎会记住上一轮的值。


for(let i=0;i<3;i++){
        let i='abc';
        console.log(i);
    }
// abc  //abc  //abc

结果是输出了三个abc  代表函数内部的变量i和循环变量i不在同一个作用域，由各自的作用域

let  不存在变量提升（变量声明）

  console.log(a);
  var a='111';  //defined
  console.log(b);
  let b='222';  //报错

var tmp=123;
    if(true){
        tmp='abc';
        let tmp;
    }  
 //tmp报错 存在全局变量tmp,但是块级作用域内let声明局部变量tmp,导致tmp赋值会报错.

ES6 明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，
从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错

暂时性死区：在let命令声明变量之前，该变量都是不可用的。

 if(true){
        tmp='abc';
        console.log(tmp);  //tmp is not defined

        let tmp;
        console.log(tmp);   // undefined

        tmp=123;
        console.log(tmp);  //123;
    }


 typeof x;  // x is not defined
 let x;

在let声明之前这个变量都会报错。

console.log(typeof x); //undefined 变量没有被声明不会报错。

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

上面代码中，调用bar函数之所以报错（某些实现可能不报错），是因为参数x默认值等于另一个参数y，而此时y还没有声明，属于”死区“。如果y的默认值是x，就不会报错，因为此时x已经声明了

 function bar(x=2,y=x) {
        return [x,y];
    }
    console.log(bar());  //[2, 2]    不会报错

2.  let 不允许在相同作用于下重复声明变量
function func() {
      let a=10;
      var a=1;
      console.log(a);
 }
  func();  //Identifier 'a' has already been declared



3.为什么需要块级作用域

ES5只有全局作用域和函数作用域，没有块级作用域，导致了很多不合理的场景。
var tmp = new Date();

function f() {
  console.log(tmp);
  if (false) {
    var tmp = 'hello world';
  }
}
f(); // undefined

内层tmp的变量提升覆盖了外层的tmp变量。

 var s='hello';
  for(var i=0;i<s.length;i++){
      console.log(s[i]);
  }
  console.log(i);
用来计数的循环变量泄露为全局变量


{{{{
  {let insane = 'Hello World'}
  console.log(insane); // 报错
}}}};
块级作用域可以任意嵌套，外层作用域无法读取内层作用域的变量。




4.块级作用域与函数声明
ES5规定，函数只能在顶层作用域和函数作用域之中声明，不能在块级作用域声明。（浏览器支持在块级作用域之中声明函数）

函数声明类似于var，即会提升到全局作用域或函数作用域的头部。
同时，函数声明还会提升到所在的块级作用域的头部。


// <!--函数声明语句-->
    {
        let a='secret';
        function f() {
            return a;
        }
    }
    //函数表达式
    {
        let a='secret';
        let f=function () {
            return a;
        };
    }

应该避免块级作用域内声明函数，可以写成函数表达式

const

1.跟let完全相同 增加几个点：
2.不允许被修改,不允许改变内存空间的地址
3.const声明和赋值必须一次性完成，并且后期不允许改变存储空间的地址

1.const 声明一个常量，一旦声明不能被改变
2.const一旦声明就必须要初始化，不能留到以后赋值。
3.和let一样只在当前作用域下生效
4.和let一样只能声明一个，没有变量提升。

const foo={};
foo.prop=123;
foo.prop
foo={}   //会报错

const a=[];
a.push('hello');
a.length=0;
a=['Dave'];   //报错

const 可以把对象冻结起来
const foo=Object.freeze({});
//常规模式下，下面一行不起作用；
// 严格模式下，这行报错
foo.prop=123

;