1）var声明及变量提升机制

1.概念

提升机制：在函数作用域或全局作用域中，通过var声明的变量，无论实际在哪里声明，最终都会被当成在当前作用域顶端声明的变量。
看个例子理解一下

function getValue (condition) {
      if(condition){
            var value = 'blue'
        }else{
        }
        console.log('v', value)
    }
    getValue()
    // 实际上，预编译阶段,value被提升到了函数顶部（变量提升发生在编译阶段），所以在else中也可以访问到value,但由于未初始化，所以值为undefined
    function getValue(condition) {
        var value
        // undefined
        if(condition){
            value = 'blue'
            // 'blue'
        }else{
            // undefined
        }
        // undefined
    }

2）块级声明

1.概念：

块级作用域：（又名词法作用域）任何一对花括号（｛和｝）中的语句集都属于一个块，在这之中定义的所有变量在代码块外都是不可见的，我们称之为块级作用域。
存在于两个区域，即函数内部或块中（字符{}之间的区域）

2.作用：用来声明在指定块的作用域外无法访问的变量。

3.let声明

把变量的作用域限制在当前代码块中，不会被提升。
看个例子理解一下

function getValue(condition) {
    if(condition){
        let value = 'blue'
    }else{
        console.log(value) // Uncaught ReferenceError: value is not defined
    }
    console.log(value) // Uncaught ReferenceError: value is not defined
}
getValue()
// 原因：let声明的，不会被提升至函数顶部，执行流离开if,value即被销毁。所以在else里面访问会报错
// 如果condition为false,value永远不会声明并初始化。

4.const声明

与let相同点：都是块级标识符。所以，常量只在当前代码块内有效，一旦执行到代码块外立即被销毁。常量也不会被提升至作用域顶部。
不同点，即const特殊之处：const声明的是常量，一旦声明后不可更改。因此，const声明的常量必须进行初始化。

const num
num = 1
console.log(num) // Uncaught SyntaxError: Missing initializer in const declaration

let num
num = 1
console.log(num) // 1

5.注意：let和const不能重复声明

如果作用域内已经声明(无论是使用var 还是let)，再用let或const关键字声明它就会抛出错误。但如果内部嵌套一个作用域，则内部作用域可以声明同名变量，不受外界影响。
看个例子理解下

var count = 30 // 30
var count = 50 // 50
let count = 80 // Uncaught SyntaxError: Identifier 'count' has already been declared
console.log(count)
if (condition = true) {
    let count = 40
    console.log(count) // 40
}
console.log(count)

6.用const声明变量

cosnt声明不允许修改绑定，但允许修改值。即可以修改对象的属性值。

const obj = {
    a: 2
}
obj.a = 5
console.log(obj) // {a:5}

const obj = {}
obj.a = 5
console.log(obj) // {a:5}

const obj = {
    a: 2
}
obj = {
    a: 3
}
console.log(obj) // Uncaught TypeError: Assignment to constant variable.

Object.freeze({}) 可以让整个对象不能被修改。

7.临时性死区

由于let和const声明的变量不会被提升至作用域顶部，如果在声明之前访问这些变量，会引发错误。

3）循环中的块级作用域绑定

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

for (let i = 0; i < 10; i++) {}
console.log(i) // Uncaught ReferenceError: i is not defined

为什么报错呢？因为变量I只存在于for循环中，一旦for循环结束，在其他地方就无法访问了。

1.循环中的函数

var funcs = []
for(var i = 0; i < 10; i++){
    funcs.push(function(){
        console.log(i)
    })
}
console.log(funcs) // funcs含有10个函数的数组
funcs.forEach(function(func){
    func() // 输出10次数字10，而不是预期是0-9
})
// 使用let声明i
var funcs = []
for(let i = 0; i < 10; i++){
    funcs.push(function(){
        console.log(i)
    })
}
funcs.forEach(function(func){
    func() // 输出0-9
})

使用let声明，每次迭代循环都会创建一个新变量，并以之前迭代中同名变量的值将其初始化。
每次循环的时候let声明都会创建一个新变量i，并将其初始化为i的当前值，所以循环内部创建的每个函数都能得到属于它们自己的I的副本。
在for-in和for-of循环中，let和const也会每次迭代时创建新的绑定，从而使循环体内创建的函数可以访问到相应迭代的值，而非最后一次迭代后的值。

var funcs = []
var obj = {
    0: 0,
    1: 1,
    2: 2
}
for (let key in obj) {
    funcs.push(function () {
        console.log(key)
    })
}
funcs.forEach(function(func){
    func() // 输出0-2
})

解释：在这个示例中，for-in循环与for循环表现的行为一致。每次循环创建的一个新的key
绑定，因此每个函数都有一个变量key的副本。
let声明在循环内部的行为是标准中专门定义的，是后来加入的。不一定于let的不提升特性相关。

2.循环中的const声明

var funcs = []
for (const i = 0;i < 10; i++) {
    funcs.push(function () {
        console.log(i)
    })
}
funcs.forEach(function(func){
    func() // Uncaught TypeError: Assignment to constant variable.
})

解释：由于i++试图修改常量，因此抛出错误。

var funcs = []
var obj = {
    0: 0,
    1: 1,
    2: 2
}
for (const i in obj) {
    funcs.push(function () {
        console.log(i)
    })
}
funcs.forEach(function(func){
    func() // 0-2
})

在for-in 或 for-of循环中使用const时的行为与使用let一致。因为每次迭代不会修改已有绑定，而是会创建一个新绑定。

4）全局块作用域绑定

var在全局作用域声明的变量会作为全局对象的属性（浏览器环境中的window对象）

var RegExp = 'hello'
console.log(window.RegExp) // hello

而使用let和const不能覆盖全局变量

let RegExp = 'hello'（或const RegExp = 'hello'）
console.log(window.RegExp) // ƒ RegExp() { [native code] }
console.log(window.RegExp === RegExp) // false