返回专栏
· 14 分钟阅读

作用域与词法作用域(Scope & Lexical Scope)


一、什么是作用域(Scope)

作用域(Scope)是指程序中标识符(变量、函数、类等)可以被访问和引用的有效范围。

简单来说,作用域回答的是一个核心问题:

在程序的某个位置,能够访问哪些变量和函数?

例如:

const name = "Reverie";

function greet() {
    const message = "Hello";
    console.log(name);
    console.log(message);
}

greet();

console.log(name);
// console.log(message); // ReferenceError

这里存在两个不同的作用域:

  • 全局作用域:定义了 name,函数内部可以访问。
  • 函数作用域:定义了 message,只能在 greet 函数内部访问。

变量能否被访问,取决于它的声明位置以及语言规定的作用域查找规则。

1.1 作用域的核心作用

作用域不仅决定变量能否访问,还承担以下职责:

  1. 名称隔离:允许不同代码区域使用相同变量名。
  2. 访问控制:限制变量和函数的可见范围。
  3. 模块封装:隐藏内部实现细节,只暴露必要接口。
  4. 依赖管理:明确函数依赖哪些外部变量。
  5. 生命周期管理的辅助:影响变量绑定何时不再可达,但不直接等同于对象生命周期。

1.2 作用域与变量声明位置

const value = 100;

function outer() {
    const value = 200;

    function inner() {
        const value = 300;
        console.log(value);
    }

    inner();
}

outer();

输出:

300

虽然三个变量都叫 value,但它们分别属于不同的作用域。

内部作用域中的变量会遮蔽(Shadowing)外部作用域中同名的变量。

二、作用域的主要类型

不同编程语言对作用域的分类存在差异。常见的分类包括全局作用域、函数作用域、块级作用域和模块作用域。

2.1 全局作用域(Global Scope)

全局作用域是程序中相对顶层的作用域。

在该作用域中声明的变量,可以在符合语言规则的其他作用域中访问。

JavaScript 示例:

const appName = "Reverie";

function showAppName() {
    console.log(appName);
}

showAppName();

appName 在全局作用域中声明,因此 showAppName 可以访问它。

不同语言对全局作用域的定义并不完全相同:

  • JavaScript:浏览器脚本和模块具有不同的顶层绑定规则。
  • Python:模块顶层名称属于模块命名空间。
  • C:文件作用域变量具有内部或外部链接属性。
  • Go:包级声明属于包块。
  • Java:不存在与 JavaScript 完全相同的自由变量式全局作用域,顶层声明通常属于类或接口。

需要注意:全局可见性不意味着变量在任何文件、模块或进程中都可以直接访问。

2.2 函数作用域(Function Scope)

函数作用域是指变量的可访问范围由函数边界决定。

JavaScript 示例:

function calculate() {
    var result = 100;

    if (true) {
        var message = "Success";
    }

    console.log(result);
    console.log(message);
}

calculate();

// console.log(result); // ReferenceError

var 声明的变量具有函数作用域,而不是块级作用域。

因此,即使 message 声明在 if 代码块中,也可以在整个函数内部访问。

函数作用域常见于:

  • JavaScript 的 var。
  • Python 的函数局部名称。
  • C、C++ 的函数内部块作用域声明(严格来说,C/C++ 主要使用块作用域概念)。
  • Java 方法内部声明的局部变量。

2.3 块级作用域(Block Scope)

块级作用域是由代码块边界限定的作用域。

常见的代码块包括:

{
    // 代码块
}

JavaScript 示例:

function test() {
    if (true) {
        let value = 100;
        const name = "Reverie";
        var status = "OK";
    }

    console.log(status);

    // console.log(value); // ReferenceError
    // console.log(name);  // ReferenceError
}

其中:

  • let:块级作用域。
  • const:块级作用域。
  • var:函数作用域或全局脚本环境中的相应绑定。

块级作用域可以避免临时变量泄漏到外层环境。

2.4 模块作用域(Module Scope)

模块作用域用于隔离模块内部声明的变量和函数。

JavaScript ES Modules 示例:

// user.js
const internalToken = "secret";

export function getUser() {
    return {
        name: "Alice"
    };
}

其他模块可以导入 getUser,但不能直接访问没有导出的 internalToken。

// app.js
import { getUser } from "./user.js";

console.log(getUser());

// internalToken 不属于当前模块的可访问绑定

模块作用域的主要价值:

  • 防止全局命名冲突。
  • 隔离模块内部实现。
  • 明确模块依赖。
  • 支持代码组织与封装。

2.5 作用域类型对比

作用域类型 主要边界 典型场景
全局作用域 程序或运行环境顶层 全局声明
函数作用域 函数边界 函数内部变量
块级作用域 {} 等代码块边界 条件和循环内部变量
模块作用域 模块边界 模块内部声明

注意:这些分类并非所有语言都采用完全一致的模型。例如,C 和 C++ 使用文件作用域、块作用域等术语;Java 使用类、方法、块和包等不同的名称可见性规则。

三、什么是词法作用域(Lexical Scope)

词法作用域(Lexical Scope),也称静态作用域(Static Scope),是指变量的可访问关系由代码在源文件中的定义位置决定,而不是由函数实际在哪里被调用决定。

这是理解闭包和函数式编程的关键。

3.1 词法作用域的核心规则

在词法作用域模型中:

  • 函数能够访问自身作用域中的变量。
  • 函数能够访问定义位置外层作用域中的变量。
  • 函数不能仅因为被某个函数调用,就自动访问调用方的局部变量。
  • 同名变量优先匹配当前作用域中的声明。

例如:

const name = "Global";

function outer() {
    const name = "Outer";

    function inner() {
        console.log(name);
    }

    inner();
}

outer();

输出:

Outer

inner 定义在 outer 内部,因此它能够访问 outer 的词法环境。

3.2 词法作用域的判断依据

判断一个函数能够访问哪些外部变量,首先看函数定义的位置,而不是调用位置。

const value = "Global";

function outer() {
    const value = "Outer";

    return function inner() {
        console.log(value);
    };
}

const fn = outer();

function execute() {
    const value = "Execute";
    fn();
}

execute();

输出:

Outer

尽管 fn 是在 execute 中调用的,但它仍然访问定义时所在的词法环境中的 value。

它不会因为调用位置变化,就自动改为访问 execute 中的变量。

3.3 词法作用域的结构

flowchart TD
    A["全局作用域"] --> B["outer 函数作用域"]
    B --> C["inner 函数作用域"]
    C --> D["查找当前作用域"]
    D --> E{"是否找到变量"}
    E -->|"是"| F["返回变量绑定"]
    E -->|"否"| G["向外层词法作用域查找"]
    G --> H{"是否到达全局作用域"}
    H -->|"否"| G
    H -->|"是"| I["查找失败"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#F3EDFC,stroke:#C4B2E3,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

四、词法作用域与动态作用域

理解词法作用域,必须与动态作用域(Dynamic Scope)进行对比。

两者最核心的区别是:

  • 词法作用域:根据函数定义位置确定变量查找关系。
  • 动态作用域:根据函数调用链确定变量查找关系。

4.1 词法作用域示例

const name = "Global";

function printName() {
    console.log(name);
}

function execute() {
    const name = "Local";
    printName();
}

execute();

输出:

Global

因为 printName 定义在全局作用域中,它访问的是定义位置对应的外层绑定。

4.2 动态作用域的假设

如果使用动态作用域模型,变量查找会沿着实际调用链进行。

在上述逻辑中:

execute
    → printName

printName 可能会找到调用方 execute 中的 name,从而输出:

Local

但 JavaScript 使用词法作用域,因此实际输出是 Global。

4.3 两者对比

对比维度 词法作用域 动态作用域
查找依据 函数定义位置 函数调用链
变量关系 编写代码时基本确定 执行时根据调用链确定
可预测性 较高 依赖运行时调用路径
闭包支持 自然形成 需要不同的环境管理机制
常见语言 JavaScript、Python、Java、C、Go、Rust 少数语言或特定动态绑定机制

现代主流通用编程语言大多采用词法作用域。

需要注意,动态作用域不等于动态类型,也不等于动态绑定。这是三个不同层次的概念。

五、作用域链(Scope Chain)

作用域链是变量查找过程中,从当前作用域逐级向外层作用域查找的逻辑关系。

当程序访问一个变量时,运行时会根据语言规则,在当前作用域及其外层环境中查找对应绑定。

5.1 作用域链示例

const a = 10;

function outer() {
    const b = 20;

    function middle() {
        const c = 30;

        function inner() {
            const d = 40;

            console.log(a, b, c, d);
        }

        inner();
    }

    middle();
}

outer();

inner 可以访问:

  • d:当前函数作用域。
  • c:外层 middle 作用域。
  • b:外层 outer 作用域。
  • a:全局作用域。

5.2 变量查找过程

flowchart TD
    A["访问变量 x"] --> B["查找当前作用域"]
    B --> C{"找到 x"}
    C -->|"是"| D["返回对应绑定"]
    C -->|"否"| E["查找外层作用域"]
    E --> F{"找到 x"}
    F -->|"是"| D
    F -->|"否"| G["继续向外层查找"]
    G --> H{"到达最外层"}
    H -->|"否"| E
    H -->|"是"| I["抛出未定义变量错误或按语言规则处理"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155

    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

5.3 变量遮蔽(Variable Shadowing)

当内层作用域声明了与外层作用域同名的变量时,内层变量会遮蔽外层变量。

const value = 100;

function outer() {
    const value = 200;

    function inner() {
        const value = 300;
        console.log(value);
    }

    inner();
}

outer();

输出:

300

查找变量时,运行时优先使用当前作用域中匹配的绑定。

如果当前作用域已经找到 value,就不会继续向外查找同名变量。

变量遮蔽在大型程序中需要谨慎使用,否则可能降低代码可读性,甚至引发意外行为。

六、词法环境(Lexical Environment)

词法作用域描述的是变量的静态可访问关系,而词法环境(Lexical Environment)是语言运行时用于实现这种关系的重要概念。

以 ECMAScript 为例,词法环境是规范中的抽象机制,用于管理标识符绑定以及外层环境引用。

6.1 词法环境的组成

从概念上看,词法环境主要包含:

  1. 环境记录(Environment Record):保存当前环境中的标识符绑定。
  2. 外层环境引用(Outer Environment Reference):指向外层词法环境。

可以抽象表示为:

LexicalEnvironment = (EnvironmentRecord,\ OuterReference)

其中:

  • EnvironmentRecord:保存变量、函数和其他声明对应的绑定。
  • OuterReference:建立当前环境与外层环境之间的查找关系。

这是一种规范层面的抽象描述,不代表引擎一定使用相同名称或结构实现。

6.2 词法环境的嵌套关系

例如:

const globalValue = 10;

function outer() {
    const outerValue = 20;

    function inner() {
        const innerValue = 30;
        return globalValue + outerValue + innerValue;
    }

    return inner();
}

可以抽象为:

全局词法环境
    └── outer 词法环境
            └── inner 词法环境

每个环境通过外层引用建立关系。

访问变量时,从当前环境开始,沿着外层引用查找。

6.3 词法环境与执行上下文

两者相关,但不能混为一谈。

概念 核心含义
词法环境 管理标识符绑定及外层环境关系
执行上下文 描述代码执行时的运行状态
作用域 规定名称可访问的范围
作用域链 描述变量向外层查找的逻辑路径

在 ECMAScript 中,执行上下文会关联词法环境、变量环境等规范结构。

不同语言和运行时不一定采用完全相同的模型。

七、词法作用域与闭包

闭包(Closure)是词法作用域在函数返回、延迟执行和环境保留等场景中的重要体现。

当函数引用了定义位置外层作用域中的变量,并且后续仍然能够访问这些变量时,就形成了闭包。

7.1 基本示例

function createCounter() {
    let count = 0;

    return function () {
        count++;
        return count;
    };
}

const counter = createCounter();

console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

这里:

  • createCounter 创建局部变量 count。
  • 内部函数引用了 count。
  • 内部函数被返回。
  • 外层函数执行结束后,返回的函数仍然可以访问 count。

这说明函数的访问能力不仅取决于当前调用栈,还取决于它所关联的词法环境。