返回专栏
· 15 分钟阅读

闭包(Closure)


一、什么是闭包

闭包(Closure)是编程语言中的一种函数机制,通常由两个部分组成:

  1. 函数对象(Function):包含可执行的代码逻辑。
  2. 词法环境(Lexical Environment):保存函数定义时能够访问的外部变量及其绑定关系。

简单来说,闭包就是一个能够记住外部作用域变量的函数。

1.1 普通函数与闭包的区别

先看一个普通函数:

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

greet();

message 是函数内部的局部变量。函数执行结束后,在没有其他引用的情况下,它不再需要被保留。

再看一个闭包:

function createGreeter() {
    const message = "Hello";

    return function greet() {
        console.log(message);
    };
}

const greet = createGreeter();

greet(); // Hello

这里发生了一个重要现象:

  • message 定义在 createGreeter 内部。
  • 内部函数 greet 引用了 message。
  • createGreeter 已经执行结束。
  • 外部仍然可以通过返回的函数访问 message。

这就是闭包的核心特征:函数可以在原定义作用域之外继续访问其词法环境中的变量。

1.2 闭包的基本结构

flowchart TD
    A["调用外层函数 createGreeter"] --> B["创建局部变量 message"]
    B --> C["定义内部函数 greet"]
    C --> D["内部函数引用 message"]
    D --> E["返回内部函数"]
    E --> F["外层函数执行结束"]
    F --> G["外部保存函数引用"]
    G --> H["调用 greet"]
    H --> I["访问原词法环境中的 message"]

    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:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

二、闭包的形成条件

闭包的形成通常涉及三个关键条件:

  1. 存在嵌套函数,即函数内部定义了另一个函数。
  2. 内部函数引用了外部函数作用域中的变量。
  3. 内部函数在外部作用域结束后仍然可以被访问或执行。

例如:

function outer() {
    let count = 0;

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

    return inner;
}

const counter = outer();

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

inner 引用了 outer 中的 count,并且在 outer 执行结束后仍然可以访问它。

需要注意,闭包的具体实现与语言有关。JavaScript、Python 等语言具有不同的闭包对象、变量绑定和作用域实现机制,不能把某一种语言的实现细节当作所有语言的统一规则。

三、闭包的底层原理:词法作用域

理解闭包,首先要理解词法作用域(Lexical Scope)。

词法作用域也称为静态作用域(Static Scope),指变量的可访问范围由代码定义时的嵌套结构决定,而不是由函数实际在哪里调用决定。

3.1 词法作用域

const name = "Global";

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

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

    return inner;
}

const fn = outer();

fn(); // Outer

虽然 inner 是在全局作用域中调用的,但它仍然能够访问定义时外层作用域中的 name。

原因是:

  • inner 定义在 outer 内部。
  • inner 的词法外层环境是 outer 的环境。
  • 变量查找按照定义时的词法环境关系进行。

3.2 作用域链

当函数访问一个变量时,运行时需要根据作用域规则查找变量。

通常可以抽象为:

flowchart TD
    A["函数访问变量"] --> B{"当前作用域是否存在变量"}
    B -->|"是"| C["读取当前作用域变量"]
    B -->|"否"| D["查找外层词法环境"]
    D --> E{"外层环境是否存在变量"}
    E -->|"是"| F["读取外层变量"]
    E -->|"否"| G["继续向上查找"]
    G --> H{"是否到达全局环境"}
    H -->|"否"| D
    H -->|"是"| I["变量未定义或无法解析"]

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

作用域链决定了函数能够访问哪些变量。

闭包则使函数在原定义环境不再由普通调用栈维持时,仍然能够访问其中需要保留的词法绑定。

四、闭包与执行上下文的关系

这是理解闭包底层机制的重要部分。

在 JavaScript 中,函数调用会创建执行上下文。执行上下文包含当前代码执行所需的信息,而词法环境负责支持变量绑定和作用域查找。

4.1 执行上下文

函数执行时,运行环境需要管理:

  • 当前函数的参数。
  • 局部变量。
  • 词法环境。
  • 外层环境引用。
  • this 等与执行相关的信息。

当函数执行结束时,其执行上下文会退出执行过程。

但是,这不代表所有相关变量都必须立即销毁。

4.2 为什么局部变量不会消失

例如:

function createCounter() {
    let count = 0;

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

const counter = createCounter();

当 createCounter 执行结束后:

  • 外层函数已经返回。
  • 内部函数仍被 counter 引用。
  • 内部函数仍然需要访问 count。
  • 因此,运行时必须保留内部函数访问所需的词法环境信息。

可以将其抽象为:

flowchart TD
    A["执行 createCounter"] --> B["创建词法环境"]
    B --> C["创建 count = 0"]
    C --> D["创建内部函数"]
    D --> E["内部函数引用 count"]
    E --> F["返回内部函数"]
    F --> G["外层执行结束"]
    G --> H["内部函数仍然被引用"]
    H --> I["保留所需词法环境"]
    I --> J["后续调用继续访问 count"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style I fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

4.3 闭包不等于整个函数调用栈被保留

这是一个容易误解的地方。

闭包并不意味着外层函数的整个执行上下文、调用栈帧都必须一直存在。

更准确地说:

  • 外层函数调用已经结束。
  • 外层函数的调用栈帧通常可以释放。
  • 内部函数需要访问的词法绑定仍然被保留。
  • 运行时可以通过堆对象、环境记录或其他内部结构保存这些信息。

在 JavaScript 引擎中,具体如何表示和优化闭包环境属于实现细节。

因此,不能简单地认为闭包就是“把函数栈帧放到堆上”。

五、闭包的变量捕获机制

闭包最关键的能力是捕获外部作用域变量。

不同语言在捕获方式上存在差异,常见情况包括:

  • 捕获变量本身。
  • 捕获变量当前值的副本。
  • 捕获对象引用。
  • 通过显式声明指定捕获方式。

5.1 JavaScript:捕获变量绑定

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

闭包访问的是外部词法环境中的 count 绑定。

每次调用都会修改同一个绑定,因此状态能够持续累积。

5.2 多个闭包共享同一个变量

function createActions() {
    let count = 0;

    return {
        increment() {
            count++;
        },

        decrement() {
            count--;
        },

        getValue() {
            return count;
        }
    };
}

const actions = createActions();

actions.increment();
actions.increment();
actions.decrement();

console.log(actions.getValue()); // 1

三个内部函数都访问同一个 count 变量。

它们共享同一个词法环境中的变量绑定,而不是各自创建独立的 count。

5.3 每次调用创建独立闭包环境

function createCounter() {
    let count = 0;

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

const counterA = createCounter();
const counterB = createCounter();

console.log(counterA()); // 1
console.log(counterA()); // 2

console.log(counterB()); // 1
console.log(counterB()); // 2

每次调用 createCounter 都会创建新的局部变量绑定。

因此:

  • counterA 访问自己的 count。
  • counterB 访问另一份 count。
  • 两个闭包之间的状态相互独立。

六、闭包与变量生命周期

普通局部变量通常随着函数调用结束而不再需要,但被闭包引用的变量可能继续存活。

6.1 普通局部变量

function normal() {
    let value = 100;
    console.log(value);
}

normal();

如果没有其他引用,normal 执行结束后,局部变量相关数据就不再需要保留。

6.2 被闭包引用的变量

function createFunction() {
    let value = 100;

    return function () {
        return value;
    };
}

const fn = createFunction();

console.log(fn()); // 100

即使外层函数执行结束,value 仍然需要被保留,因为内部函数还会访问它。

6.3 闭包变量的生命周期

可以从引用关系理解:

flowchart TD
    A["创建外层函数环境"] --> B["创建局部变量"]
    B --> C["内部函数捕获变量"]
    C --> D["外部持有内部函数引用"]
    D --> E["闭包继续访问变量"]
    E --> F{"是否仍有有效引用"}
    F -->|"是"| G["继续保留相关环境"]
    F -->|"否"| H["环境及对象变为可回收"]
    G --> F

    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:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意:

  • 闭包可达,不代表所有外层变量都必须永久保留。
  • 引擎可能只保留实际需要的变量。
  • 当闭包及其相关环境不再可达时,相关对象可以被垃圾回收。
  • 垃圾回收的具体时机由运行时决定,不能依赖立即释放。

七、闭包的典型应用场景

闭包不仅是一种语言特性,也是常见的软件设计手段。

7.1 数据封装与私有状态

闭包可以将状态保存在函数内部,只暴露有限的操作接口。

function createAccount(initialBalance) {
    let balance = initialBalance;

    return {
        deposit(amount) {
            if (amount > 0) {
                balance += amount;
            }
        },

        withdraw(amount) {
            if (amount > 0 && amount <= balance) {
                balance -= amount;
            }
        },

        getBalance() {
            return balance;
        }
    };
}

const account = createAccount(1000);

account.deposit(500);
account.withdraw(200);

console.log(account.getBalance()); // 1300

这里:

  • balance 无法通过 account.balance 直接访问。
  • 外部只能调用暴露的方法。
  • 所有方法共享同一个内部状态。

这是一种基于闭包的状态封装方式。

7.2 函数工厂

函数工厂(Function Factory)是指通过一个函数创建并返回具有特定行为的函数。

function multiplyBy(factor) {
    return function (number) {
        return number * factor;
    };
}

const double = multiplyBy(2);
const triple = multiplyBy(3);

console.log(double(10)); // 20
console.log(triple(10)); // 30

double 和 triple 分别捕获不同的 factor 值。

适用于:

  • 参数预配置。
  • 规则生成。
  • 函数定制。
  • 可复用业务逻辑。

7.3 高阶函数与回调

闭包经常与高阶函数结合使用。

高阶函数是指接收函数作为参数,或者返回函数的函数。

function createHandler(prefix) {
    return function (message) {
        console.log(prefix + message);
    };
}

const infoHandler = createHandler("[INFO] ");
const errorHandler = createHandler("[ERROR] ");

infoHandler("服务启动");
errorHandler("连接失败");

不同回调函数捕获不同的上下文信息,使同一套执行逻辑可以服务于不同业务场景。

7.4 防抖与节流

闭包经常用于保存函数执行状态。

防抖(Debounce):