var、let、const

1. var——会存在变量提升，不建议用

      var web = "echo";    ======>声明+赋值var web; web = "echo";
      var aa = 1,
          bb = "echo",
          cc = true;
      var a = b = c = 3;

var存在变量提升，把变量的声明提升到当前作用域的最前面

例一：
        console.log(web);
        var web = "echo";
执行结果为undefined
原因：存在变量提升，源代码在预解析时会变成以下代码，再执行
        var web;
        console.log(web);
        web = "echo";

例二
        function hd() {
            if (false) {
                var web = "echo";
            }
            console.log(web);
        }
        hd();
执行结果为undefined
原因：存在变量提升，源代码在预解析时会变成以下代码，再执行
        function hd() {
            var web;
            if (false) {
                web = "echo";
            }
            console.log(web);
        }
        hd();

2. let——声明之后才能使用，定义变量

（1）函数体内没有声明web，会去上层作用域内找。
        let web = "ecoh";              
        function func() {           
            console.log(web);          
        }                             
        func();  
（2）若在函数体里有let声明，必须放在使用之前，否则会产生临时性死区TDZ，报错。                   
        let web = "ecoh";              
        function func() {           
            console.log(web);  
            let web="abc";        //报错
        }                             
        func();    
 （3）里层作用域可以声明外层作用域同名变量，但不会改变外层变量。   
         function func() {
            let web = "abc";
            if (true) {
                let web = "echo";
                console.log(web); //echo
            }
            console.log(web); //abc
        }
        func();                       

3. const——声明之后才能使用，定义常量
   在同个作用域内只能声明一次变量，声明时必须同时赋值，且不可以再次修改；
   不同作用域内可以修改，两者是没有关系的，是两个不同的常量；
   可以修改引用类型变量的值

        const web = {
            a: '1'
        };
        web.a = 2;
        console.log(web.a); //2

4. 三者共同点：

• 函数中可以访问到全局变量，无论用var、let、const声明都可以访问到。

        let web = "ecoh";
        function func() {
            console.log(web); //ecoh
        }
        func();

• 若函数中声明的变量，外部不可以使用，只能在函数及其子函数中使用；若在函数中对已声明的全局变量赋值，外部也可以访问到。

        let web = "ecoh";
        function func() {
            let web = "abc";
            console.log(web);  //abc
        }
        func();
        console.log(web);  //ecoh
=========================================================
        let web = "ecoh";
        function func() {
            web = "abc";
            console.log(web); //abc
        }
        func();
        console.log(web); //abc
=========================================================
       let web = "ecoh";
        function func() {
            let web = "abc";
            function run() {
                let web = "123";
                console.log(web); //123
            }
            run();
            console.log(web); //abc
        }
        func();
        console.log(web); //echo

5. 三者不同点：

• let、const存在块作用域，var不存在
  块作用域——在语句块声明的变量，使用块级作用域要用let和const声明的变量，块级作用域没有变量提升。没有块作用域很容易污染全局。
  全局污染——变量写的不合理（如没有声明直接使用等），污染到其他环境，扰乱变量。

        var i = 99;
        for (var i = 0; i < 2; i++) {
            console.log(i);  // 0 1
        }
        console.log(i);  //2

• var 全局声明的变量存在于 window对象中,let、const不存在

        var web = 'abc';
        console.log(window.web); //abc

• var在同一个作用域下一个变量可以重复声明，const和let不可以

        var web = 'abc';
        var web = 100;
        console.log(web); //100
        let web1 = 'abc';
        // let web1 = 100;
        console.log(web1); // error:Identifier 'web1' has already been declared
        const web2 = 'abc';
        const web2 = 100;
        console.log(web2); //// error:Identifier 'web2' has already been declared

6. 冻结变量--使用Object.freeze()可以用来锁住变量，后期的修改不起作用，作废。在严格模式下会报出错误。

        "use strict" //严格模式
        const INFO = {
            url: 'https://www.echo.com',
            port: '8080'
        };
        Object.freeze(INFO);
        INFO.port = '443'; //error:Cannot assign to read only property
        console.log(INFO);