ES2015(ES6) 新增加了两个重要的 JavaScript 关键字: let 和 const。

  • let 声明的变量只在 let 命令所在的代码块内有效。
  • const 声明一个只读的常量，一旦声明，常量的值就不能改变。

在 ES6 之前，JavaScript 只有两种作用域： 全局变量 与 函数内的局部变量。

全局变量

在函数外声明的变量作用域是全局的：

  1. var carName = "Volvo";
  3. // 这里可以使用 carName 变量
  5. function myFunction() {
  6.     // 这里也可以使用 carName 变量
  7. }

全局变量在 JavaScript 程序的任何地方都可以访问。

局部变量

在函数内声明的变量作用域是局部的（函数内）：

  1. // 这里不能使用 carName 变量
  3. function myFunction() {
  4.     var carName = "Volvo";
  5.     // 这里可以使用 carName 变量
  6. }
  8. // 这里不能使用 carName 变量

函数内使用 var 声明的变量只能在函数内容访问，如果不使用 var 则是全局变量。

JavaScript 块级作用域(Block Scope)

使用 var 关键字声明的变量不具备块级作用域的特性，它在 {} 外依然能被访问到。（？？？）

  1. { 
  2.     var x = 2; 
  3. }
  4. // 这里可以使用 x 变量

在 ES6 之前，是没有块级作用域的概念的。
ES6 可以使用 let 关键字来实现块级作用域。

let 声明的变量只在 let 命令所在的代码块 {} 内有效，在 {} 之外不能访问。

  1. { 
  2.     let x = 2;
  3. }
  4. // 这里不能使用 x 变量

重新定义变量

使用 var 关键字重新声明变量可能会带来问题。
在块中重新声明变量也会重新声明块外的变量：

  1. var x = 10;
  2. // 这里输出 x 为 10
  3. { 
  4.     var x = 2;
  5.     // 这里输出 x 为 2
  6. }
  7. // 这里输出 x 为 2

let 关键字就可以解决这个问题，因为它只在 let 命令所在的代码块 {} 内有效。

  1. var x = 10;
  2. // 这里输出 x 为 10
  3. { 
  4.     let x = 2;
  5.     // 这里输出 x 为 2
  6. }
  7. // 这里输出 x 为 10

循环作用域

  • 使用 var 关键字：

    1. var i = 5;
    2. for (var i = 0; i < 10; i++) {
    3.   // 一些代码...
    4. }
    5. // 这里输出 i 为 10

  • 使用 let 关键字：

    1. let i = 5;
    2. for (let i = 0; i < 10; i++) {
    3.   // 一些代码...
    4. }
    5. // 这里输出 i 为 5

    在第一个实例中，使用了 var 关键字，它声明的变量是全局的，包括循环体内与循环体外。
    在第二个实例中，使用 let 关键字， 它声明的变量作用域只在循环体内，循环体外的变量不受影响。

局部变量

在函数体内使用 var 和 let 关键字声明的变量有点类似。
它们的作用域都是 局部的：

  1. // 使用 var
  2. function myFunction() {
  3.     var carName = "Volvo";   // 局部作用域
  4. }
  6. // 使用 let
  7. function myFunction() {
  8.     let carName = "Volvo";   //  局部作用域
  9. }

全局变量

在函数体外或代码块外使用 var 和 let 关键字声明的变量也有点类似。
它们的作用域都是全局的：

  1. // 使用 var
  2. var x = 2;       // 全局作用域
  4. // 使用 let
  5. let x = 2;       // 全局作用域

HTML 代码中使用全局变量

在 JavaScript 中, 全局作用域是针对 JavaScript 环境。
在 HTML 中, 全局作用域是针对 window 对象。
使用 var 关键字声明的全局作用域变量属于 window 对象:

  1. var carName = "Volvo";
  2. // 可以使用 window.carName 访问变量

使用 let 关键字声明的全局作用域变量不属于 window 对象：

  1. let carName = "Volvo";
  2. // 不能使用 window.carName 访问变量

重置变量

使用 var 关键字声明的变量在任何地方都可以修改：

  1. var x = 2;
  3. // x 为 2
  5. var x = 3;
  7. // 现在 x 为 3

在相同的作用域或块级作用域中，不能使用 let 关键字来重置 var 关键字声明的变量：

  1. var x = 2;       // 合法
  2. let x = 3;       // 不合法
  4. {
  5.     var x = 4;   // 合法
  6.     let x = 5   // 不合法
  7. }

在相同的作用域或块级作用域中，不能使用 let 关键字来重置 let 关键字声明的变量：

  1. let x = 2;       // 合法
  2. let x = 3;       // 不合法
  4. {
  5.     let x = 4;   // 合法
  6.     let x = 5;   // 不合法
  7. }

在相同的作用域或块级作用域中，不能使用 var 关键字来重置 let 关键字声明的变量：

  1. let x = 2;       // 合法
  2. var x = 3;       // 不合法
  4. {
  5.     let x = 4;   // 合法
  6.     var x = 5;   // 不合法
  7. }

let 关键字在不同作用域，或不同块级作用域中是可以重新声明赋值的：

  1. let x = 2;       // 合法
  3. {
  4.     let x = 3;   // 合法
  5. }
  7. {
  8.     let x = 4;   // 合法
  9. }