JavaScript 作用域、闭包与对象
2026.11.19
从一个问题说起
下面的代码里,console.log(age) 究竟能取到什么值?
function outer() {
var age = 18
function inner() {
console.log(age)
}
return inner
}
var getAge = outer()
getAge() // ??
这段代码在真实环境中执行时,getAge() 输出的值是 18。outer 函数执行完毕后,按常规理解其局部变量 age 应当随之失效,但它仍被保留并可访问。这一现象涉及三个相互关联的概念:作用域、闭包与对象。
- 作用域 —— 决定变量在哪些位置可见;
- 闭包 —— 上述"函数执行完毕仍保留其外层变量"的现象,是作用域规则与函数生存期相互作用的结果;
- 对象 —— 变量与上述规则最终承载于何种数据结构。
下文按此顺序依次讨论三者。
一、作用域:变量在哪里可见
1.1 作用域是什么
作用域(Scope)即"控制变量在哪些代码范围内可被访问"的边界。在 JavaScript 中,存在三种基本的作用域类型:
| 作用域 | 说明 | 示例 |
|---|---|---|
| 全局作用域 | 声明于所有函数之外的变量,任意位置均可访问 | var myname = '李四' |
| 函数作用域 | 函数内声明的变量,仅可在函数内部访问 | outer 内的 var age = 18 |
| 块级作用域 | let / const 与 {} 语句块共同构成独立作用域 | if (true) { let a = 2 } 中的 a |
[!TIP] 二者区别:
var仅受函数作用域约束,let/const同时受块级作用域约束。
1.2 可见性的单向性:内层可见外层
关于跨作用域访问,只需掌握一条总规则:
函数内部可以访问外部声明的变量;函数外部不能访问函数内部声明的变量。
"能访问参数""能访问外层变量"等情形均为上述规则的推论——函数体内的每个标识符,均先从自身作用域查找,未找到则向上一层作用域查找,直至全局作用域,若仍未找到则报错。查找方向自内而外、单向进行。
1.3 作用域链:变量查找的顺序
当引擎执行函数时,会为其创建对应的执行上下文。查找变量时,引擎沿一条链逐级检查:
- 在当前执行上下文内查找;
- 未找到 → 顺着
outer指向的外层,查找上一级执行上下文; - 直至全局执行上下文——找到则返回其值,仍未找到则返回
undefined或抛出错误。
这条逐级向外的查找链,即为作用域链(Scope Chain)。
[!NOTE] 需注意:这条链在代码定义阶段即已确定,而非在函数被调用时才临时建立。这一特性引出了下文的"词法作用域"。
1.4 词法作用域:依据定义时而非调用时
词法作用域(Lexical Scope) 指的是:函数体内的变量引用,绑定于函数定义时的位置,而非函数被调用时的位置。
看一个最容易踩坑的例子:
var myname = '李四'
function bar() {
console.log(myname) // 问:这里取到谁的 myname?
}
function foo() {
var myname = '张三'
bar() // bar 是全局定义的,跟 foo 无关
}
foo() // 输出 '李四',不是 '张三'
bar 虽然是在 foo 内部被调用的,但 bar 定义于全局作用域,因此其中的 myname 绑定到全局的 myname('李四')。变量解析依据的是函数定义所在的位置,而非函数被调用的位置。
欺骗词法作用域:eval() —— eval() 可将字符串当作代码执行,等于在运行时动态改变变量的解析位置,从而绕过词法作用域。该做法既影响执行性能,也存在安全风险,应当避免使用。
1.5 块级作用域的暂时性死区(TDZ)
let / const 有一个陷阱:在它声明之前访问它,哪怕在同一个作用域里,也会抛错(不是 undefined)。这叫暂时性死区(TDZ, Temporal Dead Zone):
let a = 1
if (true) {
console.log(a) // ❌ 暂时性死区:这里直接报错,而不是 undefined
let a = 2
}
由于块内存在 let a 的声明,从该块开始直至声明所在行的这段区间内,a 均处于死区状态,在此区间访问 a 会直接抛出错误。
1.6 调用栈:函数调用的执行顺序
函数调用依赖栈(Stack)——一种先进后出(LIFO)的数据结构。每次调用会向栈中压入一个"帧"(记录局部变量与返回地址),函数返回时弹出。随调用层层压入、返回时层层弹出,栈顶始终为当前正在执行的帧,由此构成调用栈(Call Stack)。
[!NOTE] 调用栈与"作用域链"是两种不同的机制:调用栈管理"函数如何返回",作用域链决定"变量向何处查找"。应予以区分。
二、闭包:函数对外层变量的保留
2.1 为什么会有闭包
回到开头的问题。根据词法作用域的规则,inner 定义于 outer 内部,因此有权访问 outer 的 age。但一个关键问题随之产生:outer 执行完毕后应回收其执行上下文,age 是否随之销毁?
JavaScript 的处理方式是:当 inner 仍被外部引用(此处为 getAge)时,outer 的执行上下文不会被整体回收。其中被 inner 引用的变量(此处为 age)将以一个集合的形式继续存在于调用栈中。这个被保留下来的集合,即闭包(Closure)。
[!TIP] 可以理解为:闭包 = 内部函数 + 其引用的外部变量。它使内部函数在外部函数执行结束后,仍能访问外部函数作用域内声明的变量。
2.2 得与失
| 内容 | 说明 | |
|---|---|---|
| ✅ 优点 | 延长变量生命周期 | 变量的存活期随内部函数而延长,外部函数返回后仍可访问 |
| ✅ 优点 | 封装私有变量 | 变量不直接暴露,仅能通过内部函数提供的接口读写 |
| ⚠️ 缺点 | 可能造成内存泄漏 | 被闭包捕获的变量持续占用内存而不释放;长期使用后若不再需要,应手动置空相关引用,避免持续占用内存 |
2.3 返回函数:将外部变量随函数一并保留
这是闭包最典型的形态——返回一个内部函数,使外部变量随其一同保留:
function createPrinter() {
var prefix = '要打印:'
let suffix = '(完)'
function print() {
console.log(prefix + '内容' + suffix)
}
return print
}
var myPrint = createPrinter()
myPrint() // 要打印:内容(完)—— createPrinter 已执行完毕,prefix、suffix 仍被保留
createPrinter 返回了 print,而 print 引用了 prefix / suffix,因此即使 createPrinter 已执行完毕,这两个变量仍因被闭包捕获而保留,此即延长变量生命周期。开头的 age 之所以仍可访问,也是同一原理。
2.4 封装私有变量:仅通过方法读写
另一种常用做法是返回一个带方法的对象,将变量隐藏于闭包中,仅允许通过方法对其进行读写。外部无法直接访问变量本身,只能调用接口方法:
function makeCounter() {
var count = 0 // 私有变量——外部不可直接访问
return {
increment: function () { count++ },
read: function () { return count }
}
}
var counter = makeCounter()
counter.increment()
console.log(counter.read()) // 1
counter.count // undefined,外部无法访问该变量
上述模式即为 JavaScript 中实现"私有成员"的方式。
2.5 状态的持续累积:计数器示例
闭包不仅支持读取,还能使状态持续累积。每次调用内部函数,修改的仍是同一个被捕获的 i:
function add(i = 0) {
i++
console.log(i)
return function () {
i++
console.log(i)
}
}
let next = add() // 1
next() // 2
next() // 3
next() // 4
i 持续存在于闭包之中。注意:add() 仅调用一次即返回 next,此后 next() 被多次调用,每次均针对同一个被捕获的 i 执行 i++,因此该值单调递增——此处并非各次各自拷贝,而是共享同一份状态。
2.6 var 的陷阱:循环中的共享变量
var 不具备块级作用域,在循环中与闭包结合时容易出现数据共享问题:
var arr = []
for (var i = 1; i <= 5; i++) {
function foo(j) {
arr.push(function () {
console.log(j)
})
}
foo(i) // 把 i 的"当前值"作为 j 传进去
}
for (var k = 0; k < arr.length; k++) {
arr[k]() // 1 2 3 4 5
}
[!NOTE] 为何不能直接写
console.log(i)? 由于var i在循环中仅存在单一变量,若所有函数均直接引用i,则循环结束后它们读取到的都是同一个最终值6。将当前值作为参数j传入foo,相当于在每轮迭代中将当时的i分别捕获进独立的闭包——这是规避var变量共享的常用办法。
更简便的修法:使用 let 声明循环变量。 let i 在每轮迭代中会生成一个相互独立的 i,闭包即可分别捕获各自的值,结果同为 1 2 3 4 5:
var arr = []
for (let i = 1; i <= 5; i++) {
arr.push(function () {
console.log(i)
})
}
for (let k = 0; k < arr.length; k++) {
arr[k]() // 1 2 3 4 5
}
(此例亦印证了 1.1 节:let 的块级作用域使每轮迭代中的 i 相互独立,互不影响。)
2.7 块级作用域 + 作用域链:就近查找与同名屏蔽
再回到作用域链,看一段同时混有函数作用域、块级作用域和同名变量的例子:
function bar() {
var myname = '曹老板' // 函数作用域
let test1 = 100
if (1) {
let myname = '邢同学' // 块内同名,屏蔽掉上面那个 myname
console.log(test1) // test1?→ 本块没有,往外一层,在 bar 函数作用域找到 100
}
}
function foo() {
var myname = '煌煌'
{ bar() } // bar 定义在全局,跟 foo 无关
}
var myname = '付总'
foo() // 输出 100
这段输出的值是 100。console.log(test1) 所在块(if 块)内未声明 test1,于是沿作用域链向外一层查找,恰好在 bar 自身的函数作用域中找到 let test1 = 100,即取值于此——并未一路查询至全局作用域。
该示例还包含两个细节,正好回顾前两节内容:
- 块内的
let myname会遮蔽bar中同名变量myname,故此处打印的是块内变量,但不影响test1的查找。 bar虽在foo内部被调用,但bar定义于全局作用域,其变量解析依据的是自身定义处的链,与foo无关——再次印证 1.4 节:变量解析依据定义处,而非调用处。
三、对象:规则落到哪里
3.1 万物皆对象?
"JavaScript 万物皆对象"这一表述并不完全准确。更为准确的说法是:对象是 JS 组织数据的核心结构,函数与数组亦属于对象。但确实存在部分不属于对象的特殊"原始值"。先加以区分:
基本类型(原始值):number、string、boolean、null、undefined、symbol、bigint
引用类型(对象):object {}、array []、function(){}
[!NOTE]
Symbol的一个特性:每次创建的Symbol均唯一,即使描述相同也不相等。let a = Symbol('a') let b = Symbol('a') console.log(a === b) // false
3.2 对象的增删改查
对象本质上是"键值对"容器。除固定的键名外,还可用变量作为键,并动态添加或删除属性:
let obj = { name: '张三', age: 18 }
obj.girlfriend = '李四' // 增
obj.age = 20 // 改
delete obj.girlfriend // 删
let key = 'hello'
obj[key] = 'world' // 用变量当键动态添加
console.log(obj)
3.3 构造函数:批量造对象
逐一手工创建每个对象效率较低,由此引入构造函数(Constructor)——以 new 调用的函数,用于批量创建结构相同的实例:
function Car(color) {
this.name = '奔驰'
this.price = 1000000
this.color = color // 用传入的 color 初始化
this.engine = 'V82.0'
}
let car1 = new Car('红色')
let car2 = new Car('蓝色')
let car3 = new Car('黄色')
此外,JS 内置了 Object、Array、Function 等构造函数,因此 new Array() 与 [] 等价,new Object() 与 {} 等价:
let arr = new Array()
arr.push(1)
console.log(arr) // [1]
3.4 原型与原型链:方法从哪来
构造函数批量创建对象时,若每个实例各自复制一份方法,会造成内存浪费。JS 的解决办法是原型(Prototype):
prototype(显式原型):每个函数自带的一个属性,其值为一个对象。__proto__(隐式原型):每个对象自带的一个属性,其值亦为一个对象。
两者最重要的关系是:实例对象的 __proto__ 等于其构造函数的 prototype。
于是引擎找属性时遵循一条链:
先找对象自己显式的属性 → 没有 → 去它的
__proto__(原型)上找 → 还没有 → 顺着原型再向上 … 直到尽头。
这条"向上找"的链,就是原型链(Prototype Chain)。
沿用 3.3 节的 Car:将方法定义在其 prototype 上,所有实例即可共享该方法,而无需各自复制一份:
// 沿用 3.3 的 function Car(color) { ... }
Car.prototype.info = function () {
return '我是一辆 ' + this.color + ' 的奔驰'
}
let car1 = new Car('红色')
let car2 = new Car('蓝色')
car1.info() // car1 自己没有 info,沿原型链找到它
car2.info() // 所有实例共享同一个方法
3.5 包装类:为什么原始值不能加属性
一个常见疑问是:原始值(如字符串)不是对象,能否为其添加属性?结论是:不会报错,但该属性不会保留。
原因在于**包装类(Wrapper)**机制:当书写一个字符串字面量时,引擎会临时以 new String(...) 将其包装为对象;但由于底层仍是原始值,引擎随后会立即执行一次"拆箱"还原。因此属性无法保留:
var str = 'hello'
str.a = 2 // 引擎临时包成对象加了个 a,然后拆箱,a 没留下
console.log(str.a) // undefined —— 原始值不保存属性
console.log(str) // hello
[!TIP] 结论:原始类型无法长期保存属性;只有对象(引用类型)可以。如需添加属性,应创建对象。
收束:三者并非孤立
回到开头的问题:getAge() 为何输出 18?
- 依据 词法作用域 的规则,
inner有权访问outer内的age; - 依靠 闭包,
outer执行完毕后,age因仍被inner引用而得以保留; - 而通过对象或构造函数的方式"返回一组方法"时,实际正是在以 对象 承载闭包。
综上,作用域规定了变量可见性的规则,闭包是该规则下的特殊情形,对象则是承载这些变量的结构。 三者考察的是同一问题的不同侧面:变量在何处可见、何时被保留、以何种结构组织。将三者结合理解,比把它们作为几条孤立定义分别记忆更为完整。