JavaScript 作用域、闭包与对象

21 阅读12分钟

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 作用域链:变量查找的顺序

当引擎执行函数时,会为其创建对应的执行上下文。查找变量时,引擎沿一条链逐级检查:

  1. 在当前执行上下文内查找;
  2. 未找到 → 顺着 outer 指向的外层,查找上一级执行上下文;
  3. 直至全局执行上下文——找到则返回其值,仍未找到则返回 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 引用而得以保留;
  • 而通过对象或构造函数的方式"返回一组方法"时,实际正是在以 对象 承载闭包。

综上,作用域规定了变量可见性的规则,闭包是该规则下的特殊情形,对象则是承载这些变量的结构。 三者考察的是同一问题的不同侧面:变量在何处可见、何时被保留、以何种结构组织。将三者结合理解,比把它们作为几条孤立定义分别记忆更为完整。