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

首先，一个常见的问题是，ECMAScript 和 JavaScript 到底是什么关系？
 
      ECMAScript是一个国际通过的标准化脚本语言。JavaScript由ECMAScript和DOM、BOM三者组成。可以简单理解为：ECMAScript是JavaScript的语言规范，JavaScript是ECMAScript的实现和扩展。
 
        2011 年，ECMAScript 5.1 版发布。之前我们大部分人用的也就是ES5
 
        2015 年 6 月，ECMAScript 6 正式通过，成为国际标准。
 
ES6的好处
 ES6的出现为我们前端带来了很多方便之处，以前用js几十行才实现的一个功能，ES6几行代码就能简单的实现，ES6新增的一些特性，改变了很多弊端之处，比如新出现的let、const，实现了块级作用域功能，减少了以前var的全局变量，箭头函数代替词法作用域的"this" 等等，在这里就不再做更多的举例子，想了解更多请参考 https://www.w3cschool.cn/ecmascript/pgms1q5d.html，今天主要跟大家一起了解一下var、let、const之间的区别
 
var、let、const的区别
 
var定义的变量，没有块的概念，可以跨块访问, 不能跨函数访问。
let定义的变量，只能在块作用域里访问，不能跨块访问，也不能跨函数访问。
const用来定义常量，使用时必须初始化(即必须赋值)，只能在块作用域里访问，而且不能修改 

<script type="text/javascript">
    // 块作用域
    {
        var a = 1;
        let b = 2;
        const c = 3;
        // c = 4; // 报错
        var aa;
        let bb;
        // const cc; // 报错
        console.log(a); // 1
        console.log(b); // 2
        console.log(c); // 3
        console.log(aa); // undefined
        console.log(bb); // undefined
    }
    console.log(a); // 1
    // console.log(b); // 报错
    // console.log(c); // 报错
 
    // 函数作用域
    (function A() {
        var d = 5;
        let e = 6;
        const f = 7;
        console.log(d); // 5
        console.log(e); // 6  
        console.log(f); // 7 
 
    })();
    // console.log(d); // 报错
    // console.log(e); // 报错
    // console.log(f); // 报错
</script>
 
很明显在函数外输出变量i的时候，报i未定义，var在函数内命名的变量是只在整个函数作用域内起作用
 
let不像var那样会发生“变量提升”现象。所以，变量一定要在声明后使用，否则报错。
 
let在同一块作用域内不能重复声明变量，var 可以重复声明 
 
 const
 
const与let上面特点一样，但是也有不同点，let声明的是变量，const声明的是常量，只读，修改值会报错，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 可以

js中存在三种声明变量的方式 var let const，但是他们之间的区别很多却分不清
 
var
 
var只有函数作用域，没有块作用域，可以声明全局/局部变量（在一共函数内声明的变量，只在该函数有效）
var定义的变量不能跨函数访问，但是可以跨块访问！
var 定义的变量如果不初始化会输出undefined，但不会报错
可以重复定义，后定义的会覆盖先定义的
 
//3
var aaa;
console.log(aaa);   //会输出undefined，并不会报错
//-----------------------------------------
var a = 1;   //全局变量
console.log("全局变量a："+a);    //全局变量a： 1

function A(){
    a=2;
    console.log("局部变量a:"+a);  //局部变量a: 2
    
}
A();
console.log("调用A函数，a变为函数A内部修改的值："+a);   //调用A函数，a变为函数A内部修改的值：2
//---------------------------------------------
var b=1;
var b=2;
console.log(b);  //2,后面的声明覆盖了前面的声明
 
let
 
let是块级作用域，函数内部使用let定义后，对函数外部无影响
let定义的变量只能在块作用域中访问，不能跨块访问，更不能跨函数访问
不能变量声明提前，否则会报错
不能重复定义，否则会报错
 
//---1------
let a =1;
console.log("全局变量a："+a); // 1
function A(){
    let a = 2;
    console.log("函数内部定义a："+a);  //2
}
A();
console.log("A()函数调用后，let定义的a值在函数内部修改"+a);  //1  并不能访问到
//---2-----
var b=1;
{
    let b=2;
    console.log(b);  //  2
}
console.log(b);   //1

//---3------
console.log(aaa);
let aaa=1;   
//会进行报错，不能变量声明提前
//----4-------
let p = 1;
let p = 2;
console.log(p);  //重复定义，会报错


 
const
 
const 定义的变量不可以修改，并且必须进行初始化
const一般用来声明常量，并且声明的常量不允许改变的，(只读属性)，因此必须在声明的同时进行赋值
const也是块级作用域，与let相同，只能在块作用域里访问，存在暂时性死区，不存在变量声明提前，不允许重复定义
 
const a =1;   //正确
const b;   //报错
//-----------------
const c=1;
const c=1;
//重复定义会报错