顺着作用域链和 outer 指针,一次性看懂闭包底层逻辑

10 阅读6分钟

前言

很多同学学习闭包的时候,背了一堆定义,却始终搞不懂: 闭包和作用域链是什么关系?为什么函数 A 执行完了,里面的变量还能被访问?闭包凭什么能延长变量生命周期?

很多教程直接把闭包单独拿出来讲,很容易让大家觉得闭包是一个独立、特殊的语法。 但实际上,闭包是词法作用域 + 作用域链带来的自然结果,它和我们上一篇讲的预编译、AO、调用栈是一套体系。 这篇文章我们就顺着 V8 的视角,从作用域链开始,一步步拆解闭包,搞懂它的原理、使用场景、隐患。

1. 作用域链(变量查找的底层规则)

  • 每个执行上下文(AO/GO)身上都自带一个 outer 指针,这个指针在函数定义的时候就确定好了,不是调用的时候!它指向这个函数书写位置对应的外层作用域。
  • 变量查找流程:优先在当前 AO 找 → 找不到,跟着 outer 跳到上层的 AO/GO 继续找 → 一直找到 GO,还找不到就报 is not defined。这条由 outer 串起来的链式查找路径,就是作用域链。

示例:

// Demo:outer指针由【定义位置】决定,不是调用位置
function outer() {
  let a = 100
  var b = 20
  function inner() {
    var c = 50
    console.log(a,b,c)
  }
  inner()
}

let a = 200
outer()
  1. 函数 inner 定义在 outer 函数内部,所以 inner 的 outer 指针在定义时就固定指向 outer 的作用域,和在哪里调用 fn 无关, 而outer的 outer 指针则指向全局作用域。
  2. 执行 fn() 的时候,开启 inner 的执行上下文,先在 inner 的 AO 里找变量 a,b,c,找到了c,拿到 c = 50 ,找不到 a , b ,name顺着 outer 指针去到 outer 的 AO,拿到 a = 100, b = 20,此时尽管 outer 的 outer 指针所指向的 GO 中还有 a = 200,但是作用域链不会优先去全局拿,因为 outer 指针锁定的是书写位置的外层。所以输出的结果为100 20 50.

2. 闭包

什么是闭包

前置铺垫:我们前面知道,普通函数执行结束之后,它的执行上下文 AO 会弹出调用栈,内部局部变量失去引用,被垃圾回收器 GC 回收销毁。闭包,就是打破这个常规流程的特殊情况。

  1. 基础前提:词法作用域
    函数 B 定义在 A 的内部,在书写阶段,B 的 outer 指针就已经绑定到 A 的作用域。所以天然拥有访问 A 内部变量的权限,这是闭包能够访问外层变量的底层基础,不是闭包额外赋予的能力。
  2. 核心触发条件:内部函数被带出外层函数
    仅仅只是在 A 里面定义 B、并且在 A 内部调用 B,并不会产生闭包。 这种场景下,A 执行完,B 也执行完毕,没有外部引用继续持有 B,A 的 AO 正常出栈销毁,局部变量直接回收,和普通函数没有任何区别。
    只有当 B 通过return、赋值给全局变量、作为回调传递等方式,脱离 A 函数的执行环境,拿到 A 的外面去调用,闭包才会被激活。
    3.反常现象
    当 A 执行完成,本来 AO 要从调用栈弹出、整体销毁。但是因为全局还有变量持有 B 的引用,B 的 outer 指针又指向 A 的作用域,B 依赖 A 里面的变量才能正常运行。
    V8 会识别到:A 中的部分变量还在被持续引用,不能直接回收。于是 A 的执行上下文不会整体销毁,仅把 B 用到的变量单独保留下来,形成这个独立的变量集合,也就是闭包。

示例:

// 闭包标准demo:内部函数被return出去,在外部调用
function A() {
  let num = 10
  function B() {
    console.log(num)
    num++
  }
  return B
}

const funcB = A()
funcB()
funcB()
funcB()
  1. 执行 A(),创建 A 的 AO,压入调用栈,在 AO 中注册变量 num、函数 B。
  2. A 执行到 return,把函数 B 返回,赋值给全局变量funcB;此时 A 的代码执行结束,AO 准备出栈。
  3. 但是全局变量funcB保存了 B 的引用,B 的 outer 指针指向 A 的作用域,B 依赖变量 num;V8 判定 num 还存在有效引用,A 的 AO 无法全部销毁,num 被保留,闭包形成。
  4. 后续每次执行funcB(),都会沿着 B 的 outer 指针,访问到闭包里面保存的 num,并且修改它的值。
    所以输出结果为:
10
11
12

我们再放一段对照代码,直观感受没有闭包的场景:

function A() {
  let num = 10
  function B() {
    console.log(num)
  }
  B() // 只在A内部直接调用,没有把B带出A
}
A()
A()

B 仅仅在 A 函数内部调用,A 执行结束之后,没有任何外部变量持有 B。A 的 AO 正常弹出调用栈,num 直接被回收。两次调用 A,都会重新创建全新的 AO、全新的 num,互不影响,所以两次输出都是 10,不存在闭包。
所以输出结果为:

10
10

闭包的优缺点

优点

  1. 延长变量生命周期:正常局部变量,外层函数执行完就销毁。闭包可以让变量脱离外层函数的执行周期,长久驻留内存,后续多次调用内部函数都可以持续读写同一份变量,计数器就是最典型的应用.
  2. 封装私有变量:闭包是实现私有数据最经典的方案。变量定义在外层函数中,全局作用域无法直接访问、修改,只能通过我们主动暴露出去的方法操作,避免全局变量污染,控制数据的读写权限。 示例:
function makeAdd() {
  let n = 1
  return function () {
    n++
    console.log(n)
  }
}

const add = makeAdd()
add()
add()
add()
  1. makeAdd 执行完毕后,按理局部变量 n 应该被销毁;
  2. 因为内部函数被返回赋值给全局 add,形成闭包,n 被保留;
  3. 每次调用 add(),操作的都是同一个 n。

此时外部直接访问 n 是拿不到的

console.log(n) // Uncaught ReferenceError: n is not defined

缺点

容易造成内存泄漏:不是闭包本身就是内存泄漏,是不合理使用闭包才会引发泄漏。只要闭包的引用一直存在,被捕获的变量就不会被回收。如果长期闲置不用的闭包没有手动释放引用,它持有的数据会一直占用堆内存,内存占用持续上涨,形成内存泄漏。
如何防止内存泄露,示例:

function makeAdd() {
  let n = 1
  return function () {
    n++
    console.log(n)
  }
}
const add = makeAdd()
add()
// 不需要闭包了,切断引用,回收
add = null

add = null 之后,没有变量持有内部函数,闭包的引用链断开,变量 n 就可以被垃圾回收,避免内存一直占用。

总结

每个执行上下文有 outer 指针,串联成作用域链,用来向上查找变量;当内部函数被带出外层函数外部调用,就形成闭包,留住外层变量,延长生命周期、实现私有封装;代价是使用不当容易内存泄漏。