JavaScript高级程序设计中的闭包与作用域链重点梳理

作者:异步漫步时间:2026-11-19 22:17:34浏览:158

系统梳理《JavaScript高级程序设计》中闭包与作用域链的核心底层机制,详细剖析执行上下文生命周期、活动对象、[[Scope]]内部属性、标识符解析流程以及闭包堆内存驻留模型与经典避坑方案。

前端底层核心原理 · 红宝书深度解析
体系梳理:执行上下文 · 作用域链 · 活动对象 · 内存回收机制
JavaScript高级程序设计中的闭包与作用域链重点梳理

闭包(Closure)与作用域链(Scope Chain)是《JavaScript高级程序设计》(常称“红宝书”)中最具深度且容易被误解的核心章节。本质上,作用域链是执行环境在创建时确立的一条指向变量对象(或活动对象)的物理指针列表,专用于有序检索标识符;而闭包则是指引用了另一个函数作用域中变量的函数对象。本文紧扣书中关于执行环境、调用栈、活动对象(AO)、[[Scope]]内部属性及垃圾回收的论述,系统梳理从底层指针链条到堆内存驻留模型的关键运作机理,并提供经典陷阱的工程规避方案。

一、执行环境、变量对象与作用域链的构建机制

在理解闭包之前,必须先厘清执行环境(Execution Context,现代规范多称执行上下文)与作用域链的形成过程。在 JavaScript 中,代码的执行必须处于某个具体的执行环境中。全局执行环境是最外层的环境,而在函数被调用时,JavaScript 引擎会为该函数创建专属于它的函数执行环境,并将其推入环境栈(Call Stack)的栈顶。

每一个执行环境内部都关联着一个变量对象(Variable Object,VO)。执行环境中定义的所有变量、函数声明和形参都作为属性保存在该变量对象中。对于函数而言,其变量对象被称为活动对象(Activation Object,AO)。活动对象在最开始时仅包含一个默认的 arguments 对象(包含 callee、length 和实际传入的参数映射),随着函数代码的执行,形参、局部变量和内部函数会被陆续填充进去。

作用域链的物理形态,实质上是一个指向各个变量对象或活动对象的指针列表。这个链条的构建分为两个决定性阶段:

  • 函数定义阶段:函数在被创建时,会隐式生成一个内部属性 [[Scope]]。这个属性会静态捕获创建该函数时其外层执行环境的作用域链,并将所有父级变量对象的指针有序保存在 [[Scope]] 中。这一机制奠定了 JavaScript 纯粹的词法作用域(静态作用域)特性。
  • 函数调用阶段:当函数被实际执行时,JavaScript 引擎创建对应的执行环境,首先通过复制函数自身的 [[Scope]] 属性中的对象来构建该环境的作用域链;随后创建函数自己的活动对象(AO),并用作变量对象推入作用域链的最前端(下标 0 处)。
JavaScript高级程序设计中的闭包与作用域链重点梳理
图1:执行上下文(Execution Context)与作用域链指针体系结构

如图1所示,当内部匿名函数在 createComparisonFunction 中运行时,其作用域链包含了三个指针:

  1. 位置 [0]:指向匿名函数自身的活动对象(包含传入的比较对象参数及本地运算变量)。
  2. 位置 [1]:指向外部包含函数 createComparisonFunction 的活动对象(包含参数 propertyName 和实参列表)。
  3. 位置 [2]:指向最外层的全局变量对象 Global VO(在浏览器中即 window)。

这种由指针串联而成的层级结构,直接决定了后续代码在执行标识符解析时的查找顺序。

二、标识符解析的推导步骤与运行生命周期

在函数内部读取或写入一个变量(如 propertyName)时,JavaScript 引擎会触发标识符解析(Identifier Resolution)机制。标识符解析是一个沿着作用域链前端逐步向后搜索变量名的线性过程。

整个过程遵循严格的“就近优先”与“短路匹配”规则:搜索首先从作用域链前端(即当前函数的活动对象 AO)开始。如果找到了与变量名匹配的属性,则立刻停止搜索并返回其值;如果自身 AO 中不存在该属性,则沿着作用域链中的指针继续追踪到下一个包含函数的活动对象;以此类推,直到搜索到最外层的全局变量对象。如果直至全局对象依然未找到该标识符,则会在非严格模式下解析失败抛出 ReferenceError: variable is not defined。

JavaScript高级程序设计中的闭包与作用域链重点梳理
图2:函数调用、作用域链组装与标识符解析五步推导流程

从代码执行生命周期的角度,图2清晰归纳了这五个关键推导步骤:

  1. 步骤 1(函数声明阶段):函数对象实例化,内部属性 [[Scope]] 静态保存当前外层环境的作用域链列表。
  2. 步骤 2(调用压栈与实例化):函数触发执行,创建执行环境并压入环境栈,实例化自己的活动对象(AO)并装载 arguments 与局部变量声明。
  3. 步骤 3(作用域链组装):复制 [[Scope]] 作为基础骨架,将自身的 AO 推入链首(下标 0),完成动态执行链路闭环。
  4. 步骤 4(标识符逐级解析):遇到变量时自底向上查询;若局部变量与外层变量同名,将在此步产生变量遮蔽(Shadowing),外层变量被屏蔽。
  5. 步骤 5(环境销毁与分流):普通函数执行完毕后上下文出栈并释放 AO;而当存在闭包时,生命周期将进入分流状态。

性能注意:标识符在作用域链中所处的位置越深,读取和写入的速度就越慢。在现代 V8 等高效 JIT 引擎中虽然已有内联缓存(Inline Cache)等优化,但在高频执行的热点循环中,将深层作用域链上的全局变量或外层对象属性显式缓存到局部变量中(即作用域链 [0] 处),依然是《JavaScript高级程序设计》推荐的经典优化实践。

三、闭包的形成机理与堆内存驻留模型

理解了作用域链的指针特性后,闭包的形成机制与内存驻留现象便迎刃而解。《JavaScript高级程序设计》给出的经典定义非常精准:闭包是指有权访问另一个函数作用域中的变量的函数。创建闭包最常见的方式,就是在外层函数内部显式创建并返回另一个内部函数。

请看《JavaScript高级程序设计》中的经典案例代码:

function createComparisonFunction(propertyName) {
    // 返回一个内部匿名函数,该函数引用了外部的 propertyName
    return function(object1, object2) {
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];

        if (value1 < value2) {
            return -1;
        } else if (value1 > value2) {
            return 1;
        } else {
            return 0;
        }
    };
}

// 创建比较函数:此时 createComparisonFunction 执行完毕
var compareNames = createComparisonFunction("name");

// 调用匿名内部函数
var result = compareNames({ name: "Nicholas" }, { name: "Greg" });

// 手动解除引用,释放内存
compareNames = null;

按照常规逻辑,当 createComparisonFunction("name") 调用完毕后,它的执行环境就从调用栈中弹出了。那么,为什么后续单独执行 compareNames(...) 时,内部函数依然能够准确访问到当时传入的实参 "name" 呢?

JavaScript高级程序设计中的闭包与作用域链重点梳理
图3:普通函数执行销毁 vs 闭包跨作用域堆内存驻留模型对比

核心原因在于执行环境栈出栈并不等同于堆内存对象被销毁:

  • 在普通函数调用中(图3左侧模式A),函数执行完毕后,执行环境出栈,其活动对象(AO)不再被任何代码所引用。垃圾收集器(现代浏览器主流采用标记清除算法)在遍历对象图时,判定该 AO 为不可达(Unreachable),便会在下一次回收周期直接将其占用的内存回收。
  • 但在闭包场景中(图3右侧模式B),createComparisonFunction 虽然执行完毕且上下文出栈,但其返回的匿名函数被赋给了全局变量 compareNames。这个匿名函数的 [[Scope]] 属性依然牢固地持有着指向 createComparisonFunction 活动对象的指针!
  • 因为全局变量 compareNames 是垃圾回收的根节点(GC Root),由它通过引用链延伸出的内部函数以及内部函数的 [[Scope]] 链条上的外层 AO 始终处于“可达”状态。因此,垃圾回收器绝对不能将其回收。

这就是闭包能够“跨越时空”保留外部变量的底层本质。然而,这也意味着包含这些变量的整个活动对象都会持续驻留在堆内存中。如果大量滥用闭包而未及时清理,会造成内存占用急剧膨胀甚至内存泄漏。正如代码最后所示,通过执行 compareNames = null; 切断全局引用,闭包与外部 AO 才会从根节点断开,进入可回收状态。

四、高频实战场景与经典陷阱深度剖析

在《JavaScript高级程序设计》关于闭包的探讨中,有两类最为典型的陷阱与一类核心应用场景被反复推敲:循环中的变量引用陷阱、this 对象的闭包绑定偏差,以及模块私有化模式。

1. 经典循环与变量绑定陷阱

在 ES6 引入块级作用域 let 之前,var 声明的变量只具备函数级作用域。在循环体内部创建闭包时,极易陷入全部闭包共享同一个活动对象变量的误区:

// 错误示例:共享同一个 i 变量
function createFunctions() {
    var result = new Array();

    for (var i = 0; i < 10; i++) {
        result[i] = function() {
            return i;
        };
    }

    return result;
}

var funcs = createFunctions();
// 读者预期:funcs[0]() 返回 0,funcs[1]() 返回 1 ...
// 实际运行输出:每一个函数调用 funcs[k]() 全部返回 10!

底层原因解析:每个内部函数的作用域链中保存的都是 createFunctions 的同一个活动对象(AO)。在 createFunctions 循环执行完毕时,该 AO 中的变量 i 的最终值已经固定为 10。当随后调用各个函数时,它们沿着作用域链检索到的都是同一个变量 i。

红宝书经典解法(立即执行函数 IIFE 创建独立作用域):

// 解决方案 1:使用 IIFE 强行复制变量值
function createFunctionsFixed() {
    var result = new Array();

    for (var i = 0; i < 10; i++) {
        result[i] = (function(num) {
            return function() {
                return num; // 引用当前立即执行函数独立 AO 中的形参 num
            };
        })(i); // 将当前的 i 作为实参按值传递
    }

    return result;
}

通过在每次循环中构造一个匿名函数并立即执行,实参 i 按值传入并作为形参 num 保存在当前 IIFE 的独立活动对象中。这样,每个返回的闭包分别持有了 10 个不同的外层活动对象指针,从而成功保留了各自独立的值(在 ES6 中,直接将 var i 改为 let i 亦能在词法解析阶段为每个迭代自动生成独立的块级环境)。

2. 闭包中的 this 与 arguments 遮蔽问题

在闭包中使用 this 对象常常产生意料之外的结果。根据规则,每个函数在被调用时都会自动取得两个特殊内部变量:this 和 arguments。内部函数在搜索这两个变量时,只会搜索到自身的活动对象为止,因而永远不可能直接跨作用域访问外部函数中的 this 和 arguments。

var name = "The Window";

var object = {
    name: "My Object",
    getNameFunc: function() {
        return function() {
            // 此时由于没有外部环境指定,匿名函数执行时的 this 指向全局 window
            return this.name;
        };
    }
};

// 执行结果输出:"The Window"(非严格模式)而非 "My Object"
console.log(object.getNameFunc()());

规范解决方案:如果希望闭包能够访问包含函数的 this,必须在外部包含函数中把该 this 显式暂存到一个闭包能够访问的普通局部变量中(如 var that = this; 或使用 ES6 词法继承的箭头函数):

var objectFixed = {
    name: "My Object",
    getNameFunc: function() {
        var that = this; // 将外部活动对象的 this 指针缓存至普通变量 that
        return function() {
            return that.name; // that 遵循作用域链普通标识符解析规则
        };
    }
};

console.log(objectFixed.getNameFunc()()); // 正确输出:"My Object"

3. 模块模式(Module Pattern)与特权方法

在工程实践中,闭包最经典的正向用途莫过于实现私有变量与特权方法(Privileged Method)。通过利用闭包保持对内部变量的独占访问,可以实现完全封装、杜绝外部直接篡改内部状态的数据安全结构:

function createPerson(name) {
    // 私有变量与私有函数:外部无法直接读取与修改
    var _name = name;
    var _accessCount = 0;

    // 返回的对象字面量携带特权方法(闭包)
    return {
        getName: function() {
            _accessCount++;
            return _name;
        },
        setName: function(value) {
            if (typeof value === "string" && value.trim().length > 0) {
                _name = value;
            }
        },
        getStats: function() {
            return "属性读取次数: " + _accessCount;
        }
    };
}

var person = createPerson("Nicholas");
console.log(person.getName()); // 输出:"Nicholas"
console.log(person._name);    // 输出:undefined(外部不可直达)
console.log(person.getStats()); // 输出:"属性读取次数: 1"

五、核心知识体系全景总结

为了便于在日常开发与技术面试中建立清晰稳固的心智模型,下表将《JavaScript高级程序设计》关于作用域链与闭包的核心知识维度进行横向归纳:

知识维度 核心底层机制 实战要点与避坑准则
执行环境与栈 调用函数时创建环境并入栈,决定变量对象的激活状态。 调用栈过深会导致栈溢出(Stack Overflow);函数返回后环境出栈。
[[Scope]] 属性 函数定义时刻静态捕获外部环境作用域链指针。 词法作用域在编写代码时确立,与后续在哪里调用完全无关。
作用域链解析 由指针构成的有序链表;从下标 0 的自身 AO 线性向上单向搜索。 优先读取自身 AO,同名变量产生遮蔽;深层查找有微小性能开销。
闭包堆内存驻留 返回函数保持对外部包含函数 AO 的强引用,阻止垃圾回收。 不再使用的闭包必须显式赋值为 null 解除引用,防范内存膨胀。
this/arguments 绑定 每个函数内部自动生成专属的 this 与 arguments。 内部函数无法直接穿透作用域获取外层 this,需使用 that 缓存或箭头函数。
JavaScript高级程序设计中的闭包与作用域链重点梳理
图4:JavaScript闭包与作用域链核心知识体系全景架构图

归结起来,《JavaScript高级程序设计》中对闭包与作用域链的论述,本质上是把执行栈的动态压栈/出栈过程、词法作用域的静态指针链,以及堆内存中对象的生命周期三者统一了起来。只要牢牢把握“作用域链由指针数组组成、内部函数静态复制外部链条、GC 只清理不可达对象”这三大底层事实,无论是复杂的模块封装还是偶发的闭包内存问题,都能迎刃而解。

作者最新文章
相关文章
更多