一、什么是闭包
闭包(Closure)是编程语言中的一种函数机制,通常由两个部分组成:
- 函数对象(Function):包含可执行的代码逻辑。
- 词法环境(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
二、闭包的形成条件
闭包的形成通常涉及三个关键条件:
- 存在嵌套函数,即函数内部定义了另一个函数。
- 内部函数引用了外部函数作用域中的变量。
- 内部函数在外部作用域结束后仍然可以被访问或执行。
例如:
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):