JavaScript 作用域

作用域是什么

参考和摘录自《你不知道的JavaScript（上）》

编译原理

通常将 JavaScript 归类为“动态”或“解释执行”语言，但事实上它是一门编译语言。但与传统的编译语言不同，它不是提前编译的，编译结果也不能在分布式系统中进行移植。

【传统编译语言编译步骤】：

• 分词/词法分析（Tokenizing/Lexing）：这个过程会将由字符组成的字符串分解成有意义（对编程语言来说）的代码块，这些代码块被称为词法单元（token）。例如，var a = 2;。这段程序通常会被分解为如下词法单元：var、a、=、2、;。空格是否会被当作词法单元，取决于空格在这门语言中是否具有意义。
• 解析/语法分析（Parsing）：将词法单元流（数组）转换成一个由元素逐级嵌套所组成的代表了程序语法结构的树。这个树被称为“抽象语法树”（Abstract Syntax Tree，AST）。
• 代码生成：将 AST 转换为可执行代码的过程被称为代码生成。这个过程与语言、目标平台等息息相关。抛开具体细节，简单来说就是有某种方法可以把 var a = 2; 的 AST 转化为一组机器指令，用来创建一个叫作 a 的变量（包括分配内存等），并将一个值储存在 a 中。

比起那些编译过程只有三个步骤的语言的编译器，JavaScript 引擎要复杂得多。例如，在语法分析和代码生成阶段有特定的步骤来对运行性能进行优化，包括对冗余元素进行优化等。

首先，JavaScript 引擎不会有大量的（像其他语言编译器那么多的）时间用来进行优化，因为与其他语言不同，JavaScript 的编译过程不是发生在构建之前的。对于 JavaScript 来说，大部分情况下编译发生在代码执行前的几微妙（甚至更短！）的时间内。

简单地说，任何 JavaScript 代码片段在执行前都要进行编译（通常就在执行前）。因此，JavaScript 编译器首先会对 var a = 2; 这段程序进行编译，然后做好执行它的准备，并且通常马上就会执行它。

理解作用域

学习作用域的方式是将这个过程模拟成几个人物之间的对话。

演员表

• 引擎：从头到尾负责整个 JavaScript 程序的编译及执行过程。
• 编译器：引擎的好朋友之一，负责语法分析及代码生成等工作。
• 作用域：引擎的另一位好朋友，负责收集并维护由所有声明的标识符（变量）组成的一系列查询，并实施一套非常严格的规则，确定当前执行的代码对这些标识符的访问权限。

对话（举例）

在执行 var a = 2; 这段代码时，引擎会认为这里有两个完全不同的声明，一个由编译器在编译时处理，另一个则由引擎在运行时 处理。

编译器首先会将这段程序分解成词法单元，然后将词法单元解析成一个树结构，最后开始进行代码生成：

1. 遇到 var a，编译器会询问作用域是否已经有一个该名称的变量存在于同一个作用域的集合中。如果是，编译器会忽略该声明，继续进行编译；否则它会要求作用域在当前作用域的集合中声明一个新的变量，并命名为 a。
2. 接下来编译器会为引擎生成运行时所需的代码，这些代码被用来处理 a = 2 这个赋值操作。引擎运行时会首先询问作用域，在当前的作用域集合中是否存在一个叫作 a 的变量。如果是，引擎就会使用这个变量；如果否，引擎会继续查找该变量。如果最终找到了这个变量，就会将 a 赋值给它。否则引擎就会抛出一个异常。

【总结】：变量的赋值操作会执行两个动作，首先编译器会在当前作用域中声明一个变量（如果之前没有声明过），然后在运行时引擎会在作用域中查找该变量，如果能够找到就会对它赋值。

编译器有话说

引擎在查找变量的过程由左右能够与进行协助，但是引擎执行怎样的查找，会影响最终的查找结果。

【查找类型】：

• LHS 查询：赋值操作的目标是谁？
• RHS 查询：谁是赋值操作的源头？

【L 和 R 的含义】：分别代表变量出现的位置在赋值操作的左侧和右侧。也就是说，当变量出现在赋值操作的左侧时，执行 LHS 查询。当变量出现在赋值操作的右侧时，执行 RHS 查询。

【注意】：RHS 查询与简单地查找某个变量的值别无二致，而 LHS 查询则是试图找到变量的容器本身，从而可以对其赋值。从这个角度说，RHS 并不是真正意义上的“赋值操作的右侧”，更准确地说“非左侧”。可以将其理解成 retrieve his source value（取到它的源值），这意味着“得到某某的值”。

【示例】：

console.log(a); // RHS 引用
a = 2; // LHS 引用

function foo(a) {
    console.log(a); // 2
}

foo(2);

【解释】：

1. 执行 foo() 函数的调用需要对 foo 进行 RHS 引用。
2. 参数传递过程中的隐式分配，此时进行 LHS 查询。
3. console.log() 本身也需要一个引用才能执行，因此会对 console 对象进行 RHS 查询，并且检查得到的值中是否有一个叫作 log 的方法（RHS 查询）
4. console.log(a) 对 a 进行 RHS 引用。

【对话的形式来解释】：

引擎：我说作用域，我需要为 foo 进行 RHS 引用。你见过它吗？
作用域：别说，我还真见过，编译器那小子刚刚声明了它。它是一个函数，给你。
引擎：哥们太够意思了！好吧，我来执行一下 foo。
引擎：作用域，还有个事儿。我需要为 a 进行 LHS 引用，这个你见过吗？
作用域：这个也见过，编译器最近把它声明为 foo 的一个形式参数了，拿去吧。
引擎：大恩不言谢，你总是这么棒。现在我要把 2 赋值给 a。
引擎：哥们，不好意思又来打扰你。我要为 console 进行 RHS 引用，你见过它吗？
作用域：咱俩谁跟谁啊，再说我就是干这个。这个我也有，console 是个内置对象。给你。
引擎：么么哒。我得看看这里面是不是有 log()。太好了，找到了，是一个函数。
引擎：哥们，能帮我再找一下对 a 的 RHS 引用吗？虽然我记得它，但想再确认一次。
作用域：放心吧，这个变量没有变动过，拿走，不懈。
引擎：真棒。我来把 a 的值，也就是 2，传递进 log()。
......

作用域嵌套

作用域是根据名称查找变量的一套规则。实际情况下，通常需要同时顾及几个作用域。

当一个块或函数嵌套在另一个块或函数中时，就发生了作用域的嵌套。因此，在当前作用域中无法找到某个变量时，引擎就会在外层嵌套的作用域中继续查找，直到找到该变量，或抵达最外层的作用域（也就是全局作用域）为止。

function foo(a) {
    console.log(a + b);
}

var b = 2;

foo(2); // 4

对 b 进行的 RHS 引用无法在函数 foo 内部完成，但可以在上一级作用域（在上面例子中是在全局作用域中）中完成。

【小剧场】：

引擎：foo 的作用域兄弟，你见过 b 吗？我需要对它进行 RHS 引用。
作用域：听都没听过，走开。
引擎：foo 的上级作用域兄弟，咦？有眼不识泰山，原来你是全局作用域大哥，太好了。你见过 b 吗？我需要对它进行 RHS 引用。
作用域：当然了，给你吧。

遍历嵌套作用域规则：引擎从当前的执行作用域开始查找变量。如果找不到，就向上一级继续查找。当抵达最外层的全局作用域时，无论找到还是没找到，查找过程都会停止。

异常

【问】：为什么区分 LHS 和 RHS 是一件重要的事情？

【答】：因为在变量还没有声明（在任何作用域中都无法找到该变量）的情况下，这两种查询的行为是不一样的。

举例说明

function foo(a) {
    console.log(a + b);
    b = a;
}

foo(2);

第一次对 b 进行 RHS 查询时是无法找到该变量的。也就是说，这是一个“未声明”的变量，因为在任何相关的作用域中都无法找到它。

如果 RHS 查询在所有嵌套的作用域中遍寻不到所需的变量，引擎就会抛出 ReferenceError 异常。

【注意】：ReferenceError 是非常重要的异常类型。

相较之下，当引擎执行 LHS 查询时，如果在顶层（全局作用域）中也无法找到目标变量，全局作用域中就会创建一个具有该名称的变量，并将其返还给引擎，前提是程序运行在非“严格模式”下。

作用域：“不，这个变量之前并不存在，但是我很热心地帮你创建了一个。”

ES5 中引入了“严格模式”。同正常模式，或者说宽松、懒惰模式，严格模式在行为上有很多不同。其中一个不同的行为是严格模式禁止自动或隐式地创建全局变量。因此，在严格模式中 LHS 查询失败时，并不会创建并返回一个全局变量，引擎会抛出同 RHS 查询失败时类似的 ReferenceError 异常。

接下来，如果 RHS 查询找到了一个变量，但是你尝试对这个变量的值进行不合理的操作，比如试图对一个非函数类型的值进行函数调用，或者引用 null 或 undefined 类型的值中的属性，那么引擎会抛出另外一种类型的异常，叫作 TypeError。

ReferenceError 同作用域判别失败相关，而 TypeError 则代表作用域判别成功了，但是对结果的操作是非法或不合理的。

小结

• 作用域是一套规则，用于确定在何处以及如何查找变量（标识符）。如果查找的目的是对变量进行赋值，那么就会使用 LHS 查询；如果目的是获取变量的值，就会使用 RHS 查询。赋值操作符会导致 LHS 查询。= 操作符或调用函数时传入参数的操作都会导致关联作用域的赋值操作。
• JavaScript 引擎首先会在代码执行前对其进行编译，在这个过程中，像 var a = 2; 这样的声明会被分解成两个独立的步骤：
  1. 首先，var a 在其作用域中声明新变量。这会在最开始的阶段，也就是代码执行前进行。
  2. 接下来，a = 2 会查询（LHS 查询）变量 a 并对其进行赋值。
• LHS 和 RHS 查询都会在当前执行作用域中开始，如果有需要（也就是说它们没有找到所需的标识符），就会向上级作用域继续查找目标标识符，这样每次上升一级作用域，最后抵达全局作用域，无论找到或没找到都将停止。
• 不成功的 RHS 引用会导致抛出 ReferenceError 异常。不成功的 LHS 引用会导致自动隐式地创建一个全局变量（非严格模式下），该变量使用 LHS 引用的目标作为标识符，或者抛出 ReferenceError 异常（严格模式下）。