/*
* let和const的区别
* es6中的变量提升
* let 【变量】
* 1. let声明的变量没有变量提升
* 2. let不允许重复声明
* 3. let声明的变量不会给全局对象window增加属性
*
* const  【常量=》静态变量】
* 1. let的变量提升的特点，const都具有
* 2. const声明的变量必须赋值
* 3. const声明的变量不允许修改,其中可以修改引用数据类型的值，
* */

var let const 区别

var：变量提升（无论声明在何处，都会被提至其所在作用于的顶部）

let：无变量提升（未到let声明时，是无法访问该变量的）

const：无变量提升，声明一个基本类型的时候为常量，不可修改；声明对象可以修改

var和let的区别
1.函数作用域 vs 块级作用域
var 和 let 第一点不同就是 let 是块作用域，即其在整个大括号 {} 之内可见。如果使用 let 来重写上面的 for 循环的话，会报错
var：只有全局作用域和函数作用域概念，没有块级作用域的概念。但是会把{}内也假称为块作用域。
let：只有块级作用域的概念 ，由 { } 包括起来，if语句和for语句里面的{ }也属于块级作用域。
2.变量提升 vs 暂时性死区
let 和 var 的第二点不同是，在变量声明之前就访问变量的话，会直接提示 ReferenceError，而不像 var 那样使用默认值 undefined:
var 存在变量提升，而 let，const（后面会提及）声明的变量却不存在变量提升，所以用 let 定义的变量一定要在声明后再使用，否则会报错。

ES6明确规定，如果区块中存在let命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。所以在代码块内，使用let命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”（temporal dead zone，简称 TDZ）。

3.let不允许重复声明变量
var：变量可以多次声明，而let不允许在相同作用域内，重复声明同一个变量。
<script>
    if (true) {
      let a;
      let a; // Uncaught SyntaxError: Identifier 'a' has already been declared
    }

    if(true){
      var d;
      var d;    //不会报错
    }

    if (true) {
      var c;
      let c; // Uncaught SyntaxError: Identifier 'c' has already been declared
    }

    if (true) {
      let d;
      var d; // Uncaught SyntaxError: Identifier 'd' has already been declared
    }
</script>

4.全局变量vs全局对象的属性
ES5中全局对象的属性与全局变量基本是等价的，但是也有区别，比如通过var声明的全局变量不能使用delete从 window/global （ global是针对与node环境）上删除，不过在变量的访问上基本等价。
ES6 中做了严格的区分，使用 var 和 function 声明的全局变量依旧作为全局对象的属性，使用 let, const 命令声明的全局变量不属于全局对象的属性。
<script>
    var a = 10;
    console.log(window.a); //10
    console.log(this.a) //10

    let b = 20;
    console.log(window.b); // undefined
    console.log(this.b) // undefined
</script>

const声明的常量
除了let以外，ES6还引入了cons，const 和 let 的作用域是一致的，不同的是 const 变量一旦被赋值，就不能再改变了，但是这并不意味着使用 const 声明的变量本身不可变，只是说它不可被再次赋值了，而且const 声明的变量必须经过初始化。
注：复合类型const变量保存的是引用。因为复合类型（如数组和对象）的常量不指向数据，而是指向数据(heap)所在的地址(stack)，所以通过 const 声明的复合类型只能保证其地址引用不变，但不能保证其数据不变。所以将一个对象声明为常量必须非常小心。
简单数据类型（数值，字符串，布尔值）：值保存在变量指向的那个内存地址，因此等同于常量。
复合类型的数据（对象和数组）：变量指向的是内存地址，保存的是一个指针，const只能保存这个指针地址是固定的，至于他指向的数据结构是不是可变的，就完全不能控制了。
最后
但是什么时候用 var、let 或 const 呢？我的建议是，大多数情况下都使用 const，除非你知道你的变量的值还会被改变，以上大概是总结后的内容，看来，还是多用 let 、const 吧。

var let const区别
var 是es5中的，  let 和 const 是es6中的

1.var定义变量，没有块的概念，可以跨块访问，不能跨函数访问，不初始化出现undefined，不会报错。
2.let定义变量，只能在块作用域里访问，也不能跨函数访问，对函数外部无影响。
3.const定义常量，只能在块作用域里访问，也不能跨函数访问，使用时必须初始化(即必须赋值)，而且不能修改。
        function fn(){
            var a = 1;
            let b = 2;
            const c = 3;
            console.log(a) // 1
            console.log(b) // 2
            console.log(c) // 3
        }
        fn();
        console.log(a) // 报错
        console.log(b) // 报错
        console.log(c) // 报错
        //由此可知，不管是 var let const 都不能跨函数访问


        {
            var d = 1;
            let e = 2;
            const f = 3;
            console.log(d) // 1
            console.log(e) // 2
            console.log(f) // 3
        }
        console.log(d) // 1
        console.log(e) // 报错
        console.log(f) // 报错
        //由此可知 var 可以跨块作用，而 let const 不行
        //*注： for、if属于块作用域

        {
            var aa;
            let bb;
            const cc; //报错
        }
        //const必须定义之后立即赋值，因为const定义的是常量
        //而 var 和 let 可以不用

        {
            var g = 1;
            let h = 2;
            const i = 3;
            g = 4;
            h = 5;
            i =6; //报错
        }
        //const不能被重新赋值，而 var 和 let 可以

JavaScript中var let const区别 以及作用域引用类型
var let const
let 声明变量
var 声明变量
const 声明常量(不会发生变化的量) ，
var
缺点：1 变量提升：变量声明的时候提升到最初始的的位置
​          声明变量可以在使用之后，不符合预期
​         2 可以重复声明，引起歧义。
​         3 function 其实也是声明变量
<script>
	var a;
    var a;
    var a;
    //连续定义三个 a，系统不会报错而将var换为let的时候系统会出现报错
</script>

let
let 声明变量
​      优点
​      1 声明前不能使用，保证代码的执行顺序
​      2 在let之前又暂时性的死区，在后面
​      3 不允许重复声明，一旦声明就会报错
<script>
		//暂时性的死区
        let a//在这之前的a操作全部会报错。
	
</script>

const
const 声明常量(不会发生变化的量)
​     1 注意常量名要大写，不允许修改
​      2一定要在声明变量的时候设置初始值。
​    // 作用域：变量的生效范围，有限的/
作用域：
全局作用域
​      直接写在最外面的的变量拥有的作用域是全局作用域
​      任何地方可以访问的，那就是全局变量
函数作用域
​        在函数内部声明的变量，他会在函数内部生效
块级作用域
​      变量访问的是从内到外，内部没有才会去外面
<script>
	 let a=3;//全局变量
        function foo(){
             let a=2;
            console.log(a);//输出2
        }
    	console.log(a);这里输出的是3.
    
    
     let a=3;
        function foo(){
             a=2;//去除let后，表示是对全局变量a进行修改
            console.log(a);
        }
    console.log(a);//这里输出的是2
    
     let a=3;
        function foo(a){
             a=2;
            console.log(a);输出2
        }
    console.log(a);//这里输出的是3
</script>