let与const命令

前面的话

ES5中的声明变量的方法：var 与 function命令存在很大的弊端。ES6新增let命令与const命令纠正了这些弊端。ES6一共有6种声明变量的方法。除了前的4种，还有import 与 class，后面将提到。

let命令

1：基本用法

ES6 新增let命令用于声明变量。用法与var类似，但是所声明的变量只在let命令所在的代码块有效

只在代码块内有效：

   {
        let a = 10;
        var c = 10;
    }
    console.log(a);// 报错： ReferenceError : a is not defined
    console.log(c);// 10

循环的计数器很适合let命令：

 for(let i = 0;i <10;i++)
    {
        //...
    }
    console.log(i);//ReferenceError : a is not defined只在循环体内有效

与var命令的比较：

var：

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

函数在定义时不看函数体内部的代码，当函数执行时才会去看函数体里面的代码。所有当a6函数执行时，for循环已经使i 变为10了

let：

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

当前的i只在本轮循环有效。所有每一次循环的i其实都是一个新的变量，于是时6

2: 不存在变量提升

var 命令会发生“变量提升”，即变量可以在声明之前使用，值为undefined。
let 命令纠正了这一现象，它所声明的变量只能在声明后使用，否则报错

   //var 的情况
    console.log(foo);// undefined
    var foo = 2;
    // let 的情况
    console.log(bar);// 报错
    et bar = 2;

3： 存在暂时性死区

只要块级作用域内存在let命令，它所声明的变量就绑定在这个区域，不再受外部的影响. 使用let命令声明变量前，该变量都是不可用的。这成为暂时性死区.

   // var tmp = 123;
    // if(true){
    //     tmp = 'abc';// 报错
    //     let tmp;
    // }

4 不允许重复声明

let不允许在相同作用域内重复声明统一变量

   function test() {
         // 报错 
         let a = 10;
         var  a = 10;
    }

5:块级作用域

为什么需要块级作用域？
1：防止变量相互影响
2：变量作用域使用完之后立即销毁，减少内存占用

下面这个例子：ES5的情况没有块级作用域时：输入undefined

函数内部的temp变量覆盖了外部的变量，并且存在变量提升，所以为undefined

   var temp =  new Date();
    f();// undefined
    function f() {
        console.log(temp);
        if(false){
            var temp = 'hello';
        }
    }

let实际上为JavaScript新增了块级作用域： 外层代码块不受内层代码块的影响

  function f1() {
        let n = 5;
        if(ture){
            let n = 10;
        }
        console.log(n);// 5
    }

注意： ES6允许块级作用域的任意嵌套。外层作用域无法读取内层作用域的变量。外层作用域的变量可以与内层作用域定义的变量同名
{{{{let insane = ‘hello’}}}}

6：块级作用域与函数声明

在ES5中，函数只能在顶层作用域和函数作用域中声明，不能在块级作用域中声明
两种情况在ES5中都是非法的：

    // 情况一：
    if(true)
    {
        function f() {}
    }
    // 情况二： 
    try{
        function f() {}
    }catch(e){
        // ..
    }

ES6引入了块级作用域，明确允许在块级作用域中声明函数。并且在块级作用域中定义的函数与let类似，在块级作用域之外不可引用
注意： 尽量避免在块级作用域内声明函数，因为考虑到环境的行为的差异，符合ES6 这种函数声明的代码也会报错，如果确实需要使用，可以改写成函数表达式的形式

   {
        let a = 'set';
        let f = function() {
            return a;
        }
    }

块级作用域允许声明的函数只在使用大括号的情况下成立。

  if (true) {
    function fn () {} // 合理
     }
  if (true)
  function fn () {} // 报错

7：do表达式(是一个提案)
块级作用域是没有返回值的，如果想有返回值，可以使用do,在块级作域之前加do,使它变为do表达式

  let x = do{
       let t = fn();
         t *t + 1;
   }

const 命令

声明一个只读的常量，一旦声明，常量就不能改变。也就是说const声明常量必须立即初始化，不能到后面赋值。

与let类似：只在声明所在的块级作用域内有效、存在暂时性死区、不可重复声明

const的实质：并不是变量的值不变，而是变量指向的那个内存地址不能变动。对于简单类型的数据，值就保存在指向的内存地址中，因此等于同于常量，但是对于复合类型的数据（对象与数组），变量指向的内存地址保存的只是一个指针，const只能保证这个指针是固定的至于他指向的数据结构是不是可变的，这个完全不能控制。

  const foo = {};
  foo.prop = 123;// 添加一个属性
  console.log(foo);// {prop:123}
   foo = {};// 报错，不可指向另一个地址