讲一讲闭包

最新推荐文章于 2025-12-11 21:57:31 发布

原创最新推荐文章于 2025-12-11 21:57:31 发布 · 465 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#javascript #前端 #开发语言

本文解释了JavaScript闭包的概念，包括自由变量、理论上所有函数都是闭包，以及实践中的闭包定义。通过实例讲解了执行上下文、变量对象和作用域链在闭包中的关键作用。最后，提供了一个简单的闭包示例来说明闭包如何在内存中持久化变量。

闭包的定义

MDN 对闭包的定义为：闭包就是那些能够访问自由变量的函数。

什么是自由变量呢？

自由变量是指在函数中使用，但既不是函数参数也不是函数局部变量的变量。

由此可见闭包包含两部分：函数+函数能够访问的自由变量，从技术的角度讲，所有的JavaScript函数都是闭包

var a = 1;

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

foo();

但这只是理论上的闭包，还有实践角度上的闭包：

ECMAScript中，闭包指的是：

从理论角度：所有的函数。因为它们都在创建的时候就将上层上下文的数据保存起来了。哪怕是简单的全局变量也是如此，因为函数中访问全局变量就相当于是在访问自由变量，这个时候使用最外层的作用域；
从实践角度：以下函数才算是闭包：
即使创建它的上下文已经销毁，它仍然存在（比如，内部函数从父函数中返回）；
在代码中引用了自由变量；

这就涉及到两个知识点：执行上下文和变量对象

对于每个执行上下文，都有三个重要属性：

变量对象(Variable object，VO)
作用域链(Scope chain)
this

举一个简单的例子：

var scope = "global scope"
function checkscope(){
	var scope = "local scope"
	function f(){
		console.log(scope)
	}
	return f
}
checkscope()()

执行过程：

创建全局执行上下文，全局执行上下文压入执行上下文栈，全局执行上下文初始化，初始化的同时，checkscope 函数被创建，保存作用域链到函数的内部属性[[scope]]；

ECStack = [
	globalContext
]
globalContext = {
	VO: [global],
	Scope: [globalContext.VO],
	this: globalContext.VO
}
checkscopeContext: {
	scope: [globalContext.VO]
}

执行checkscope函数，创建checkscope 执行上下文，被压入执行上下文栈；
checkscope函数执行上下文初始化，创建变量对象、作用域链、this等，同时 f 函数被创建，保存作用域链到 f 函数的内部属性[[scope]]；

ECStack = [
	checkscopeContext,
	globalContext
]
checkscopeContext: {
	AO: {
		arguments： {
			length: 0
		},
		scope: undefined,
		f: reference to function f(){}
	},
	Scope: [AO, globalContext.VO],
	this: undefined
}

checkscope函数执行完毕，从执行上下文栈弹出；

ECStack = [
	globalContext
]

执行 f 函数，创建 f 执行上下文，被压入执行上下文栈；

ECStack = [
	fContext,
	globalContext
]
fContext = {
	AO: {
		arguments: {
			length: 0
		},
	},
	Scope: [AO, checkscopeContext.AO, globalContext.VO],
	this: undefined
}

f 函数执行完毕，从执行上下文栈弹出;
全局执行上下文从执行上下文栈弹出。

f 函数在执行的时候， f 执行上下文维护了一个作用域链，

fContext = {
    Scope: [AO, checkscopeContext.AO, globalContext.VO],
}

因为这个作用域链，f 函数依然可以读取到 checkscopeContext.AO 的值，说明当 f 函数引用了 checkscopeContext.AO 中的值的时候，即使 checkscopeContext 被销毁了，但是 JavaScript 依然会让 checkscopeContext.AO 活在内存中，f 函数依然可以通过 f 函数的作用域链找到它，正是因为 JavaScript 做到了这一点，从而实现了闭包这个概念。

写一个简单的闭包

var arr = []
for(var i = 0; i < 3; i++){
	arr[i] = function(i){
		return function(){
			console.log(i)
		}
	}(i)
}
arr[0]()
arr[1]()
arr[2]()