返回探索
指南VibeFix 内容整理更新于 2026年11月18日

别再猜变量谁能看见了:闭包与作用域实战指南

闭包就是函数加上它出生时的环境。本文按 MDN 的《闭包》指南与《JavaScript 执行模型》讲清楚:词法作用域、var 与 let/const 的区别、函数工厂、私有变量、作用域链、循环里 var 的经典坑,以及白白造函数的代价。

真实照片:双手在银色笔记本键盘上敲代码,屏幕上是深色代码编辑器,桌后放着一只白色咖啡杯

先把这篇的边界说清楚。站里已经有《Promise 与 async/await 实战指南》,讲的是等一个结果回来有几种写法;这篇不讲等结果,讲的是变量的命:一个变量在代码里写在哪、能活多久、谁能看见它。还有一篇《CSS Grid 布局实战》,讲的是页面怎么摆格子,这篇不讲布局,只讲 JavaScript 里最容易让人栽跟头的两个概念:作用域和闭包。下面用到的“青石咖啡馆”是一个虚构的练手项目:一个帮街边咖啡馆做点单的网页小工具,顾客点单、选规格、加小料,程序算价格、记会员次数。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于作用域与闭包的语法和行为,都来自 MDN 的《闭包》指南与《JavaScript 执行模型》参考页,来源见每篇的 meta 信息与 evidence 记录。MDN 文档里的例子,比如 Mozilla 名字、makeAdder 加法器、三条提示的表单,都是文档自带的示例,不是真实用户数据。

第一步:变量在哪写,就在哪找——这就是词法作用域

JavaScript 里找变量,靠的是位置,不是时间。MDN 的原话是:词法作用域的意思是,解析器按变量在源代码里写的位置,来决定它在哪里可用。内层函数能看见外层函数的变量,不是因为它在外层函数运行的时候才出生,而是因为它写在外层函数里面。看 MDN 的第一个例子就明白了:init 函数里先声明了一个局部变量 name,值是 Mozilla,再在里面定义一个 displayName 函数,打印 name。调用 init 的时候,displayName 被执行,console.log 成功打印出了 Mozilla。displayName 自己一个局部变量都没有,但它写在 init 里面,所以 init 的变量它全能看见。这就是嵌套函数能访问外层作用域的意思:写在哪,就能看见哪。

这句话反过来说也成立:写在外面的东西,看不见写在里面的东西。init 里面的 name,init 外面的代码是碰不到的。作用域像一扇单向的门:里面能看见外面,外面看不见里面。很多新手第一次写代码,习惯把变量到处声明、到处用,觉得“反正都在同一个文件里”。词法作用域的第一课就是:文件不等于作用域,写的位置才是。变量声明在哪一行、嵌在第几层花括号里,决定了它能被谁看见。

第二步:var 只有两种作用域,块花括号拦不住它

在 ES6 之前,JavaScript 的变量只有两种作用域:函数作用域和全局作用域。用 var 声明的变量,要么属于一个函数,要么属于全局。这一点对从 C、Java 转过来的人特别容易踩坑,因为在那些语言里,花括号就是作用域。MDN 给了一个很直接的例子:if 语句里 Math.random 大于 0.5 就 var x 等于 1,否则 var x 等于 2,然后在 if 外面打印 x。按 C 语言的直觉,这行打印应该报错,因为 x 的作用域只在 if 的花括号里。可 JavaScript 里它不报错,x 照样能打印出来,因为 var 声明的变量不认块,花括号拦不住它,两处 var x 其实是同一个全局变量。

这个行为不是小毛病,它会在后面和闭包合谋,酿成经典大坑。先记住结论:var 只认函数和全局,不认块。写代码的时候,只要看到 var,就要多问一句:这个变量到底属于哪个函数?如果它写在任何函数外面,它就是全局的,整个文件、甚至整个页面里别的脚本都能碰到它。

第三步:let 和 const 终于让花括号算数了

ES6 引入了 let 和 const,这两个声明终于让块有了作用域。同样是上面的 if 例子,把 var 换成 const,if 外面再打印 x,就会直接报 ReferenceError:x is not defined。MDN 的原话是:在 ES6 里,块终于被当作作用域对待了,但前提是你用 let 或者 const 声明变量。ES6 还引入了模块,模块是另一种作用域。闭包能捕获所有这些作用域里的变量,函数作用域、块作用域、模块作用域,一个都不落。

对写新代码的人来说,结论很简单:默认用 const,需要改值才用 let,var 能不用就不用。这不是风格偏好,是作用域规则本身变了。用 let 和 const,变量的可见范围就和代码的缩进对得上:写在哪个花括号里,就只在那个花括号里有效。读代码的人不用再猜这个变量到底属于谁,眼睛看到哪,它就管到哪。

第四步:闭包就是函数加上它出生时的环境

作用域讲明白了,闭包就只剩一句话。MDN 的定义是:闭包是函数和它被声明时的词法环境的组合。这个环境由闭包创建时在作用域内的所有变量组成。看 MDN 的 makeFunc 例子:外层函数 makeFunc 里声明了 const name 等于 Mozilla,再定义内层函数 displayName,打印 name,最后把 displayName 返回出去。调用 makeFunc 拿到 myFunc,再调用 myFunc,照样打印出 Mozilla。第一眼看上去这不合直觉:在别的语言里,函数里的局部变量,函数跑完了就没了,name 早该消失了。可 JavaScript 里它还在,因为 displayName 这个函数实例一直攥着它出生时的词法环境,环境里有 name,所以 myFunc 被调用的时候,name 还能用。

执行模型那篇参考页把这件事说得更直白:每当一个函数被创建,它会在内部记住当前运行执行上下文的变量绑定,然后这些变量绑定可以比执行上下文活得更久。函数跑完了,栈帧弹出了,变量却因为被闭包攥着,还活着。这就是闭包的本质:它不是什么高级魔法,就是“函数把出生时的环境一起打包带走”。理解了这一点,后面所有关于闭包的用法和坑,都能顺着这句话推出来。

第五步:函数工厂——一个模子,捏出不同的函数

闭包最常见的正经用法,是函数工厂。MDN 的 makeAdder 例子只有几行,却把闭包的价值讲透了:makeAdder 接受一个参数 x,返回一个新函数,这个新函数接受参数 y,返回 x 加 y。用 makeAdder(5) 做出 add5,用 makeAdder(10) 做出 add10。add5(2) 是 7,add10(2) 是 12。add5 和 add10 共用同一份函数体定义,但各自存着不同的词法环境:add5 的环境里 x 是 5,add10 的环境里 x 是 10。MDN 的原话是:它们共享同一份函数体定义,但存储着不同的词法环境。

这就是闭包的第一个好处:把数据和操作数据的函数绑在一起。MDN 把这件事和面向对象编程做了类比:对象是把数据和操作数据的方法绑在一起,闭包则是把数据和操作数据的函数绑在一起。所以任何你本来想用“只有一个方法的对象”的地方,都可以用闭包代替。网页代码里这种场合特别多:给按钮绑点击、给输入框绑提示、给列表项绑处理,每一个回调都是一段“等用户触发时才跑”的代码,闭包让它在触发的时候,还记得自己出生时的那些变量。

第六步:字号按钮——闭包在真实页面里的样子

MDN 用调字号的按钮把闭包落到了真实页面上。思路是:正文用 12px,标题用相对单位 em,这样只要改 body 的字号,整页的字跟着一起变。JavaScript 部分是 makeSizer 函数:接受一个 size,返回一个箭头函数,箭头函数里把 document.body.style.fontSize 设成这个 size 的像素值。用 makeSizer(12)、makeSizer(14)、makeSizer(16) 做出三个函数 size12、size14、size16,分别绑到三个按钮的 onclick 上。点 12 的按钮,正文变成 12px;点 16 的按钮,正文变成 16px。

三个按钮的函数长得一模一样,区别只在各自攥着的 size 是几。这正是函数工厂的日常形态:写一次模子,批量做出带不同数据的函数。青石咖啡馆的点单页也能这么写:makeSizeButton 函数接受一个规格,比如“大杯加 4 元”,返回一个点击处理函数,点一下就把订单里的规格改成大杯、价格加 4 元。规格是几,是函数出生时就定好的,按钮被点的时候才用得上。闭包在这里不是炫技,是让“每个按钮记得自己是干什么的”最省事的办法。

第七步:私有变量——不让外面碰的,才是自己的

闭包的第二个正经用法,是做私有变量。JavaScript 在引入类之前,没有原生的私有方法写法,但用闭包可以模拟出来。MDN 的计数器例子是标准写法:一个立即执行函数里,先声明 let privateCounter 等于 0,再定义一个内部函数 changeBy,负责加减,最后返回一个对象,带着 increment、decrement、value 三个公开方法。increment 调用 changeBy(1),decrement 调用 changeBy(-1),value 返回 privateCounter 的当前值。跑一遍的结果是:初始 0,加两次变成 2,减一次变成 1。

关键在:privateCounter 和 changeBy 从外面是碰不到的。三个公开方法共享同一个词法环境,环境里有这两个私有成员;外面只能通过这三个方法间接访问,改不了、也看不见内部实现。MDN 特别指出:这三个公开方法形成闭包,共享同一个词法环境。想再要一个独立的计数器,就用 makeCounter 函数工厂:每次调用都生成一个新的词法环境,counter1 和 counter2 各自的 privateCounter 互不影响。counter1 加两次是 2,counter2 还是 0。青石咖啡馆的会员次数就能这么记:每个会员一个计数器,次数只进不出,外面只能读、不能直接改,想改只能走加一次的正经接口。

这里要分清两种共享。三个公开方法共享一个环境,是“同一个计数器,三把钥匙”;两个计数器各自独立,是“两个计数器,各自一把钥匙”。前者是模块模式,后者是函数工厂。分不清这两层,是很多人读闭包代码时晕的根源:先问“这几个函数是不是共享同一个环境”,再问“这个环境是第几次调用造出来的”,答案就清楚了。

第八步:作用域链——内层函数能一路看到最外层

闭包能看见的不只是直接外层,而是所有外层。MDN 的 sum 例子把这一点算得很清楚:全局先声明 const e 等于 10,sum(1) 返回一层函数,传 2 返回再一层,传 3 再一层,传 4 到最里层,最里层返回 a 加 b 加 c 加 d 加 e。sum(1)(2)(3)(4) 的结果是 20:1 加 2 加 3 加 4 加 10,等于 20。每一层嵌套函数都能访问外层函数的变量,MDN 的原话是:闭包能访问所有的外层作用域。

这个例子还有一个写法上的提醒:MDN 同时给出了匿名函数和具名函数 sum2、sum3、sum4 两种版本,结果一样。具名版本的好处是调试的时候栈里能看到名字,匿名版本写起来短。选哪个,看团队习惯;但无论哪种,规则不变:变量按写的位置一层一层往外找,找到全局为止,找不到就报错。闭包还能捕获块作用域和模块作用域的变量。MDN 的例子是:函数里用花括号包住 const y 等于 6,再把读取 y 的箭头函数存到外面的 getY,出了块之后直接打印 y 是 undefined,但调 getY() 还是 6。模块的例子也一样:myModule.js 里 let x 等于 5,导出 getX 和 setX,别的模块 import 之后,setX(6) 再 getX() 就是 6。块跑完了、模块的变量没直接暴露,闭包照样能读写它。

第九步:循环里的 var,是闭包最出名的坑

前面说过,var 不认块。这个毛病和闭包一合谋,就是 JavaScript 历史上最出名的坑。MDN 的表单例子是:页面上有邮箱、姓名、年龄三个输入框,每个框聚焦时,下方要显示对应的提示。setupHelp 里用 var helpText 存三条提示,再用 for 循环、var i、var item,给每个输入框绑一个 onfocus 回调,回调里显示 item.help。跑起来会发现:不管聚焦哪个框,显示的永远是最后一条“年龄”提示。

原因正是闭包的定义反过来咬人:三个 onfocus 回调都是闭包,都攥着 setupHelp 的同一个词法环境,环境里只有一个 item 变量。循环跑完的时候,item 已经指向了 helpText 的最后一条,三个回调后来执行时,读到的都是最后一条。MDN 的原话是:三个闭包共享同一个词法环境,环境里有一个值在变的变量 item;因为循环跑完时 item 已经指向最后一条,所以三个回调读到的都是它。

修法有三种,按 MDN 的顺序:第一种是用函数工厂多造一层闭包,makeHelpCallback(help) 每次调用生成一个新环境,help 就是对应的那条提示,三个回调各攥各的;第二种是用立即执行函数把当次的 item 包起来;第三种最省事:把 var 换成 let 或者 const,让每次循环都有自己的块作用域,item 每次都是新的。现代代码直接选第三种,或者干脆不用 for 循环,用 for...of 或者 forEach,item 每次迭代都是新的,闭包问题自然消失。记住判断句:循环里绑回调,先看变量是 var 还是 let——var 共享一个,let 每次一个。

第十步:闭包不是免费的,别白白造函数

闭包好用,但不是免费的。MDN 在指南结尾提醒:每个函数实例都管理自己的作用域和闭包,所以如果某个任务不需要闭包,就不要无缘无故地在别的函数里创建函数,这会同时拖累处理速度和内存消耗。例子是 MyObject 构造函数:把 getName 和 getMessage 写在构造函数里,每 new 一个对象,这两个方法就重新创建一次。改成挂到原型上,MyObject.prototype.getName,所有对象共享同一份方法定义,new 多少个对象都只创建一次。MDN 还补了一句:直接重定义整个 prototype 不推荐,正确做法是往已有的原型上逐个追加。

这条规则的实质是:闭包只在你需要它攥着环境的时候才造。需要每个对象记住自己的数据,就用闭包或者实例属性;只需要共享行为,就用原型。青石咖啡馆的例子:每个订单要记住自己的菜品和价格,订单对象用闭包或者字段都行;但“算总价”这个行为,所有订单都一样,挂原型上就够了,没必要每个订单都复制一份。反过来还有一种浪费:闭包攥着环境不放,环境里的变量就一直活着。如果一个闭包被长期挂在事件监听上,它攥着的大对象也就一直释放不掉,页面越用越慢。闭包用完要记得解绑,监听不用了就 removeEventListener,别让它一直攥着不放。

第十一步:84 次闭包事故,先对着图自查

虚构青石咖啡馆项目一个季度 84 次闭包相关事故的原因分布条形图

上图是虚构的青石咖啡馆项目一个季度的统计:和闭包、作用域相关的事故一共 84 次。循环里 var 共享变量、三个按钮全变成最后一个 30 次,占 35.7%,是最多的;两个计数器状态串了、一个会员的次数算到另一个人头上 20 次,占 23.8%;私有变量被外面直接改掉、绕过了正经接口 14 次,占 16.7%;每次 new 对象都重建方法、页面越用越慢 12 次,占 14.3%;闭包一直不放手、大对象释放不掉 8 次,占 9.5%。30 加 20 加 14 加 12 加 8 等于 84,账是平的。这些数字是编出来的例子,目的是让你一眼看到:前两类加起来快六成,而它们都是同一个根源的不同写法——没分清“一个环境”还是“每次一个环境”。

自查清单:写完带闭包的代码,逐条打勾

第一,变量声明默认用 const,需要改值才用 let,var 能不用就不用。第二,内层函数用到的变量,先问它写在哪一层、属于哪个作用域。第三,函数工厂每次调用都生成新环境,add5 和 add10 互不影响;想共享,就让几个方法共用同一个环境。第四,私有变量只通过返回的公开方法读写,外面直接碰不到。第五,循环里绑回调,先看变量是 var 还是 let:var 共享一个,let 每次一个,拿不准就用 for...of 或者 forEach。第六,不需要闭包的地方别白造函数,共享行为挂原型上。第七,闭包攥着的大对象用完要解绑,别让监听一直攥着不放。第八,调试闭包先问两个问题:这几个函数共享同一个环境吗?这个环境是第几次调用造出来的?八条里任何一条答不上来,回到对应的章节再读一遍,比多背十个 API 都有用。

阅读 0评论 0

评论 (0)

ME
0/1000
评论加载中...

原始来源

浏览项目广场发布你的项目

相关文章

真实照片:一名女子站在办公室白墙前,把彩色便利贴按行贴在墙上,手里还拿着一张粉色便利贴
指南
别再用 margin 硬凑间距了:Flexbox 一维布局实战指南

Flexbox 一次只排一个方向,排对了,导航栏、卡片墙、购物车行都听话。本文按 MDN 的《Basic concepts of flexbox》《Aligning items in a flex container》《Controlling ratios of flex items along the main axis》三篇官方文档讲清楚:两根轴、容器与项目、方向与换行、剩余空间、flex 三件套、两根轴上的对齐、间距与自动边距。

开发工作流前端工程AI 编程实践
真实照片:俯拍一双手在深色桌面上整理写了字的索引卡片,旁边是夹着表格的写字板
指南
数据先装进盒子再说话:对象与 JSON 实战指南

一张点单就是一个对象:桌号、菜品、总价、付没付钱,全按标签收在一起。本文按 MDN 的《Working with objects》《JSON》《Object》三篇官方文档讲清楚:对象字面量、点号与方括号、增删改查、for...in 配 hasOwn、方法与 this、getter 与 setter、引用与复制、Object.assign 等工具箱、空白原型对象、JSON 的严规矩,以及 stringify 与 parse 和数字精度的坑。

开发工作流前端工程AI 编程实践
真实照片:一双手在 MacBook Pro 上打字,屏幕显示改写 HTML 内容的 JavaScript 代码,白色桌面上有白色鼠标、纸张和文件夹
指南
别让函数把你绕晕:JavaScript 函数、参数与箭头函数实战指南

函数你每天都在调,这篇把你一直在做的事讲清楚。本文按 MDN 的《Functions》《Arrow function expressions》《Rest parameters》三篇官方文档讲清楚:声明与表达式、参数与实参、默认值、剩余参数、展开语法、返回值、箭头函数省写规则、this 的坑、回调与高阶函数、作用域。

工具技巧前端工程AI 编程实践