| 关键字 | 重复定义 | 修改值 | 声明提升 | 块级作用域 | 循环 |
|---|---|---|---|---|---|
| var | 可以 | 可以 | 会 | 严格来说不支持 （function可以） |
可以 |
| 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 操作符定义的变量会成为包含它的函数的局部变量。
使用 var 在一个函数内部定义一个变量，就意味着该变量将在函数退出时被销毁：
function test() {
var message = "hi"; // 局部变量
}
test();
console.log(message); // 出错！
message 变量是在函数内部使用 var 定义的。函数叫 test()，调用它会创建这个变量并给它赋值。调用之后变量随即被销毁，因此示例中的最后一行会导致错误。不过，在函数内定义变量时省略 var 操作符，可以创建一个全局变量：
function test() {
var 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);
var 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。
2.2 全局声明
与 var 关键字不同，使用 let 在全局作用域中声明的变量不会成为 window 对象的属性（var 声明的变量则会）。
var name = 'LBJhui';
console.log(window.name); // 'LBJhui'
let name = LBJhui;
console.log(window.name); // undefined
```javascript
不过，let 声明仍然是在全局作用域中发生的，相应变量会在页面的生命周期内存续。因此，为了避免SyntaxError，必须确保页面不会重复声明同一个变量。
### 2.3 for循环中的let声明
for循环的计数器，就很合适使用let命令。
```javascript
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命令。
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不在同一个作用域，有各自单独的作用域。
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 
网友评论