1. 变量声明(var,let 和 const)

变量声明(var,let 和 const)

ECMAScript 变量是松散类型的，意思是变量可以用于保存任何类型的数据。每个变量只不过是一个用于保存任意值的命名占位符。有 3 个关键字可以声明变量：var、const 和 let。

1. var 关键字

要定义变量，可以使用 var 操作符（注意 var 是一个关键字），后跟变量名（即标识符，如前所述）：

var message

这行代码定义了一个名为 message 的变量，可以用它保存任何类型的值。（不初始化的情况下，变量会保存一个特殊值 undefined）。ECMAScript 实现变量初始化，因此可以同时定义变量并设置它的值：

var message = 'hi'

这里，message 被定义为一个保存字符串值 hi 的变量。像这样初始化变量不会将它标识为字符串类型，只是一个简单的赋值而已。随后，不仅可以改变保存的值，也可以改变值的类型：

var message = 'hi'
message = 100 // 合法，但不推荐

在这个例子中，变量 message 首先被定义为一个保存字符串值 hi 的变量，然后又被重写为保存了数值 100。虽然不推荐改变变量保存值的类型，但这在 ECMAScript 中是完全有效的。

1.1. var 声明作用域

var 声明的变量被挂到 window。

使用 var 操作符定义的变量会成为包含它的函数的局部变量，意味着该变量将在函数退出时被销毁：

function test() {
  var message = 'hi' // 局部变量
}
test()
console.log(message) // 出错！

message 变量是在函数内部使用 var 定义的，函数叫 test()，调用它会创建这个变量并给它赋值。调用之后变量随即被销毁，因此示例中的最后一行会导致错误。不过，在函数内定义变量时省略 var 操作符，可以创建一个全局变量：

function test() {
  message = 'hi' // 全局变量
}
test()
console.log(message) // "hi"

去掉之前的 var 操作符之后，message 就变成了全局变量。只要调用一次函数 test()，就会定义这个变量，并且可以在函数外部访问到。

注意 虽然可以通过省略 var 操作符定义全局变量，但不推荐这么做。在局部作用域中定义的全局变量很难维护，也会造成困惑。这是因为不能一下子断定省略 var 是不是有意而为之。在严格模式下，如果像这样给未声明的变量赋值，则会导致抛出 ReferenceError

在严格模式下，不能定义名为 eval 和 arguments 的变量，否则会导致语法错误。

1.2. var 声明提升

使用 var 时，下面的代码不会报错。这是因为使用这个关键字声明的变量会自动提升到函数作用域顶部：

function foo() {
  console.log(age)
  var age = 26
}
foo() // undefined

之所以不会报错，是因为 ECMAScript 运行时把它看成等价于如下代码：

function foo() {
  var age
  console.log(age)
  age = 26
}
foo() // undefined

这就是所谓的“提升”（hoist），也就是把所有变量声明都拉到函数作用域的顶部。此外，反复多次使用 var 声明同一个变量也没有问题。

2. let 声明

let 跟 var 的作用差不多，但有着非常重要的区别。最明显的区别是，let 声明的范围是块作用域，而 var 声明的范围是函数作用域。

if (true) {
  var name = 'LBJhui'
  console.log(name) // LBJhui
}
console.log(name) // LBJhui

if (true) {
  let name = 'LBJhui'
  console.log(name) // LBJhui
}
console.log(name) // ReferenceError: name 没有定义

块作用域是函数作用域的子集，因此适用于 var 的作用域限制同样也适用于 let。

let 也不允许同一个块作用域中出现冗余声明。这样会导致报错：

let age
let age // SyntaxError；标识符age 已经声明过了

当然，JavaScript 引擎会记录用于变量声明的标识符及其所在的块作用域，因此嵌套使用相同的标识符不会报错，而这是因为同一个块中没有重复声明。

2.1 暂时性死区

let 与 var 的另一个重要的区别，就是 let 声明的变量不会在作用域中被提升。

// name 会被提升
console.log(name) // undefined
var name = 'LBJhui'

// name 不会被提升
console.log(name) // ReferenceError：name 没有定义
let name = 'LBJhui'

在解析代码时，JavaScript 引擎也会注意出现在块后面的 let 声明，只不过在此之前不能以任何方式来引用未声明的变量。在 let 声明之前的执行瞬间被称为“暂时性死区”（temporal dead zone），在此阶段引用任何后面才声明的变量都会抛出 ReferenceError。在 let 声明的作用域外对该变量使用 typeof 则不会报错，具体示例如下：

console.log(typeof value) // undefined

{
  let value = true
}

2.2 全局声明

与 var 关键字不同，使用 let 在全局作用域中声明的变量不会成为 window 对象的属性（var 声明的变量则会）。

var name = 'LBJhui'
console.log(window.name) // 'LBJhui'

let name = LBJhui
console.log(window.name) // undefined

不过，let 声明仍然是在全局作用域中发生的，相应变量会在页面的生命周期内存续。因此，为了避免 SyntaxError，必须确保页面不会重复声明同一个变量。

2.3 for 循环中的 let 声明

for 循环的计数器，就很合适使用 let 命令。

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

上面代码中，计数器 i 只在 for 循环体内有效，在循环体外引用就会报错。

下面的代码如果使用 var，最后输出的是 10。

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

上面代码中，变量 i 是 var 命令声明的，在全局范围内都有效，所以全局只有一个变量 i。每一次循环，变量 i 的值都会发生改变，而循环内被赋给数组 a 的函数内部的 console.log(i)，里面的 i 指向的就是全局的 i。也就是说，所有数组 a 的成员里面的 i，指向的都是同一个 i，导致运行时输出的是最后一轮的 i 的值，也就是 10。

如果使用 let，声明的变量仅在块级作用域内有效，最后输出的是 6。

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

上面代码中，变量 i 是 let 声明的，当前的 i 只在本轮循环有效，所以每一次循环的 i 其实都是一个新的变量，所以最后输出的是 6。你可能会问，如果每一轮循环的变量 i 都是重新声明的，那它怎么知道上一轮循环的值，从而计算出本轮循环的值？这是因为 JavaScript 引擎内部会记住上一轮循环的值，初始化本轮的变量 i 时，就在上一轮循环的基础上进行计算。

另外，for 循环还有一个特别之处，就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域。

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

上面代码正确运行，输出了 3 次 abc。这表明函数内部的变量 i 与循环变量 i 不在同一个作用域，有各自单独的作用域。for 循环的计数器，就很合适使用 let 命令。

3. const 声明

const 的行为与 let 基本相同，唯一一个重要的区别是用它声明变量时必须同时初始化变量，且尝试修改 const 声明的变量会导致运行时错误。

const age = 26
age = 36 // TypeError: 给常量赋值

// const 也不允许重复声明
const name = 'LBJhui'
const name = 'Wade' // SyntaxError

// const 声明的作用域也是块
const name = 'LBJhui'
if (true) {
  const name = 'Wade'
}
console.log(name) // LBJhui

const 声明的限制只适用于它指向的变量的引用。换句话说，如果 const 变量引用的是一个对象，那么修改这个对象内部的属性并不违反 const 的限制。

const person = {}
person.name = 'LBJhui' // ok

JavaScript 引擎会为 for 循环中的 let 声明分别创建独立的变量实例，虽然 const 变量跟 let 变量很相似，但是不能用 const 来声明迭代变量（因为迭代变量会自增）:

for (const i = 0; i < 10; ++i) {} // TypeError：给常量赋值

不过，如果你只想用 const 声明一个不会被修改的 for 循环变量，那也是可以的。也就是说，每次迭代只是创建一个新变量。这对 for-of 和 for-in 循环特别有意义：

let i = 0
for (const j = 7; i < 5; ++i) {
  console.log(j) // 7, 7, 7, 7, 7
}

for (const key in { a: 1, b: 2 }) {
  console.log(key) // a, b
}

for (const value of [1, 2, 3, 4, 5]) {
  console.log(value) // 1, 2, 3, 4, 5
}