ES6 var let const 的区别

?

var

?1. 只支持全局作用域和函数作用域

{
  var m = 2
}
console.log(m)//输出为2

?2. 不支持块级作用域

?3. 会自动提升声明

console.log(m)//输出undefined
var m = 2

?此处不会报错，因为用var声明的变量会提升声明(只提升声明)到整个作用域的开头。相当于以下代码：

var m
console.log(m)//输出undefined
m = 2

?4. 可重复声明变量

var m = 2
var m = 5

?此处不会报错。var允许重复声明变量，但它的含义是重新开辟内存空间再赋值，而并非覆盖原有的变量值

let

? 1.还支持块级作用域

{
    let m = 2
}
console.log(m)//报错

?此处报错的原因是let具有块级作用域(即一对{ }之间)

? 2.不提升声明

{
    console.log(m)//报错
    let m = 5
}

?let声明的变量智能先声明后使用

? 3.不可重复声明

{
    let m = 2
    let m = 3
    console.log(m)//报错
}

? 4.TDZ（ 暂时性死区 )

? 只要块级作用域内存在 let 命令，它所声明的变量就“绑定”（ binding ）这个区域，不再受外部的影响。
?ES6 明确规定,如果区块中存在 let命令，则这个区块对这些命令声明的变量
开始就形成封闭作用域。只要在声明之前就使用这些变量 就会报错。

var tmp = 123;
{
    tmp = 'abc '; //ReferenceError
    let tmp ;
}

const

? 1.还支持块级作用域 (同 let )

? 2.不提升声明 (同 let )

? 3.不可重复声明 (同 let )

? 4.TDZ (同 let )

? 5.声明常量

{
    const a = 2
    a = 3//TypeError: Assignment to constant variable.
}

?const声明一个只读的常量，其余与let用法一致。
?当常量保存的不是原始值而是一个地址引用时，对象的属性可改变，但不能更改它的引用

{
    const obj = {
        name:'Ann',
        age:18
    }
    obj.age = 20//不会报错
    console.log(obj.age)//输出20
    obj = {x:0,y:0}//TypeError: Assignment to constant variable.
}

============================举个栗子

?1.

{
    var count = 10
    let count = 20
    console.log(count)//报错**SyntaxError: Identifier 'count' has already been declared
}

?2.

{
    var count = 10
    if(count>0){
        let count = 40
    }
    console.log(count)//10
}

?3.

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

?let---->块作用域，函数本身有闭包的行为，会将该变量的作用域保存

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

?for形成外层作用域，循环内部为子作用域。两层作用域，使用就近的变量

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

=========================首次创作，非常激动·····(ˊ????? ? ?????ˋ)~