罗罗编程学习记录
本页内容 展开查看

03.2.1.3 作用域、闭包与提升

所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.2 JavaScript / 03.2.1 语言核心与对象模型

03.2.1.3-001 什么是词法作用域?与动态作用域有何区别?

一句话结论

词法作用域(静态作用域)由代码书写位置决定,函数定义时就确定可访问的外层作用域;动态作用域由调用位置决定。JavaScript 采用词法作用域。

概念解释

  • 词法:函数在哪里定义,就绑定哪里的外层变量。
  • 动态:函数在哪里调用,就取哪里的变量(如 bash 变量作用域)。
  • 词法作用域在编译/解析阶段确定。

原理流程

  1. 解析代码时建立作用域嵌套关系。
  2. 函数内部引用变量沿定义位置的外层链查找。
  3. 调用位置不改变作用域绑定。

代码 / 示例

const x = "outer";
function f() { console.log(x); }   // 定义在 outer 作用域
function g() { const x = "inner"; f(); }
g(); // "outer":词法作用域,f 仍取定义处的 x

常见误区

  • 误区:函数在哪调用就用哪的变量;正解:JS 按定义位置查找,与调用位置无关。
  • 误区:闭包改变了作用域规则;正解:闭包是词法作用域的运行时保留机制。

追问

  • Q:with/eval 能动态改变作用域吗? A:可以局部修改,但属于不推荐的历史特性,严格模式受限。
  • Q:作用域链在何时形成? A:解析阶段按代码嵌套建立,运行时随上下文激活。

03.2.1.3-002 作用域链是如何形成的?

一句话结论

内层作用域可访问外层作用域的变量,逐层向外串联形成作用域链;查找变量时从当前作用域开始,沿链向外直到全局作用域,找不到则报错(未声明读取)。

概念解释

  • 全局作用域在链末端。
  • 块级/函数作用域嵌套在外层链上。
  • 内层遮蔽外层同名变量。

原理流程

  1. 代码嵌套建立作用域父子关系。
  2. 每个作用域记录外层引用。
  3. 变量查找沿链向外。

代码 / 示例

全局作用域
  └ 函数 A 作用域
      └ 函数 B 作用域(查找:B → A → 全局)

常见误区

  • 误区:作用域链跨函数互相访问;正解:只有嵌套外层链可访问,兄弟作用域互不连通。
  • 误区:读取未声明变量返回 undefined;正解:读取抛 ReferenceError,typeof 是例外。

追问

  • Q:块级作用域在链中如何插入? A:{} 内 let/const 形成块作用域,嵌套在所属函数/全局链上。
  • Q:作用域链与原型链区别? A:前者是变量查找的词法层级,后者是对象属性查找的对象链。

03.2.1.3-003 执行上下文栈是什么?

一句话结论

执行上下文是代码执行环境的抽象(变量环境、词法环境、this);全局上下文入栈,函数调用压入新上下文,执行完弹出,栈顶为当前执行上下文。

概念解释

  • 全局上下文:页面/模块唯一。
  • 函数上下文:每次调用创建一份。
  • 栈结构:后进先出,递归对应栈加深。

原理流程

  1. 全局上下文入栈。
  2. 调用函数创建上下文压栈。
  3. 函数返回弹出,恢复上层上下文。

代码 / 示例

栈顶 →  f 上下文
        g 上下文
        全局上下文  ← 栈底

常见误区

  • 误区:同一函数多次调用共享一个上下文;正解:每次调用创建独立上下文,变量互不干扰。
  • 误区:上下文保存闭包变量;正解:上下文执行结束后,被闭包引用的变量环境被保留,见 03.2.1.3-012。

追问

  • Q:执行上下文包含哪些内容? A:变量对象/环境记录、作用域链、this 绑定,规范细节随版本演进。
  • Q:调用栈溢出什么错误? A:递归过深导致 RangeError: Maximum call stack size exceeded。

03.2.1.3-004 var 的变量提升是什么?

一句话结论

var 声明在执行前被提升到作用域顶部,声明部分先处理(值为 undefined),赋值留在原位;因此声明前访问变量得到 undefined,而不是未声明错误。

概念解释

  • 提升:声明位置上移,赋值不移动。
  • var 函数作用域,可重复声明。
  • 提升发生在上下文创建阶段。

原理流程

  1. 上下文创建,扫描 var 声明并初始化为 undefined。
  2. 执行到赋值语句时写入值。
  3. 声明前访问读到 undefined。

代码 / 示例

console.log(a); // undefined(提升后未赋值)
var a = 1;
console.log(a); // 1

var b = 2;
var b = 3;      // 重复声明合法,覆盖绑定

常见误区

  • 误区:提升把赋值也移到顶部;正解:只提升声明,赋值留在原位。
  • 误区:var 声明前访问报错;正解:得到 undefined,区别于未声明变量。

追问

  • Q:函数声明提升与 var 有何不同? A:函数声明整体提升,可在定义前调用;var 只提升声明绑定。
  • Q:为什么现代代码少用 var? A:函数作用域、重复声明、提升意外易引入 bug,let/const 更安全。

03.2.1.3-005 let/const 与暂时性死区(TDZ)是什么?

一句话结论

let/const 是块级作用域,声明语句执行前处于暂时性死区,访问会抛 ReferenceError;声明后才完成初始化,const 绑定不可重新赋值。

概念解释

  • TDZ:从作用域起点到声明语句之间的区间。
  • 死区内访问不返回 undefined,直接报错。
  • const 要求声明时初始化,绑定不可变(对象内容可变)。

原理流程

  1. 块作用域创建,let/const 进入 TDZ。
  2. 执行到声明语句完成初始化。
  3. 之后才可正常访问。

代码 / 示例

console.log(x); // ReferenceError:TDZ
let x = 1;

const y = 2;
// y = 3;       // TypeError:const 绑定不可重赋值
const obj = { n: 1 };
obj.n = 2;      // 合法:对象内容可改

常见误区

  • 误区:let 声明前访问得到 undefined;正解:TDZ 内访问抛 ReferenceError。
  • 误区:const 声明的对象不能修改;正解:不可变的是绑定,对象属性仍可改。

追问

  • Q:TDZ 与变量提升矛盾吗? A:let/const 也有提升(作用域内已绑定),但禁止在初始化前访问,表现为 TDZ。
  • Q:循环中 let 为什么没有 TDZ 串扰? A:每次迭代创建新绑定,见 03.2.1.3-015。

03.2.1.3-006 函数作用域与块级作用域有什么区别?

一句话结论

var 归属函数作用域,整个函数内可见;let/const 归属最近的 {} 块级作用域,块外不可见;块级作用域让变量生命周期更短、更易追踪。

概念解释

  • 函数作用域:以函数体为边界。
  • 块级作用域:if/for/{} 代码块为边界。
  • 同一作用域内 let/const 不可重复声明。

原理流程

  1. 按声明关键字确定作用域类型。
  2. 变量在对应边界内可见。
  3. 出块即脱离绑定。

代码 / 示例

function f() {
  if (true) {
    let a = 1;
    var b = 2;
  }
  console.log(b); // 2,var 函数作用域
  // console.log(a); // ReferenceError,块外不可见
}

常见误区

  • 误区:for 循环内 var 只在循环体可见;正解:var 归属外层函数作用域,循环结束仍存在。
  • 误区:块级作用域内函数声明也受限;正解:函数声明在块内的行为随历史版本有差异,建议块内用函数表达式。

追问

  • Q:模块顶层声明属于什么作用域? A:模块作用域,不挂全局对象,见 03.2.1.3-018。
  • Q:try/catch 绑定是什么作用域? A:catch 参数是块级绑定,仅 catch 块内可见。

03.2.1.3-007 闭包是什么?形成条件是什么?

一句话结论

闭包是函数与其词法作用域的组合:内部函数引用了外层函数的变量,即使外层函数执行结束,内部函数仍能访问这些变量;形成条件是内层函数引用外层变量且内层函数被外部持有。

概念解释

  • 函数定义时记录外层作用域。
  • 外层执行完,变量环境被闭包保留。
  • 闭包让私有状态在函数外持续存在。

原理流程

  1. 外层函数执行,创建局部变量。
  2. 内层函数引用这些变量。
  3. 内层函数被返回/保存到外部,外层结束后变量环境不释放。

代码 / 示例

function counter() {
  let n = 0;
  return () => ++n;
}
const c = counter();
c(); // 1
c(); // 2,n 被闭包保留

常见误区

  • 误区:闭包就是内部函数;正解:是函数 + 其词法作用域环境的组合。
  • 误区:外层函数不执行也能形成闭包;正解:需外层上下文执行过、变量被初始化并被内层引用。

追问

  • Q:闭包保存的是变量还是值? A:保存变量环境,变量值可随闭包内操作变化。
  • Q:箭头函数形成闭包吗? A:形成,词法作用域规则与普通函数一致。

03.2.1.3-008 闭包如何保留外部变量?

一句话结论

函数内部引用的外层变量被记入词法环境记录,内层函数持有该环境引用;外层上下文弹出后,环境记录因被闭包引用而不被回收,变量得以持续访问。

概念解释

  • 环境记录保存变量绑定。
  • 引用计数/可达性决定是否回收。
  • 闭包延长了变量生命周期。

原理流程

  1. 外层上下文创建环境记录。
  2. 内层函数闭包引用该记录。
  3. 外层弹出后记录仍可达,保留变量。

代码 / 示例

function outer() {
  let secret = "hidden";
  return {
    get: () => secret,
    set: (v) => { secret = v; }
  };
}
const api = outer();
api.get(); // "hidden",secret 未被回收

常见误区

  • 误区:闭包复制了外部变量值;正解:引用同一变量环境,修改会反映到闭包内。
  • 误区:所有外层变量都被保留;正解:只有被内层引用的变量环境整体保留,未引用部分可被回收。

追问

  • Q:多个闭包共享同一外层变量吗? A:同一外层调用产生的闭包共享该次调用的变量环境。
  • Q:闭包内变量何时释放? A:闭包引用不可达后,变量环境随 GC 回收。

03.2.1.3-009 闭包有哪些典型应用?

一句话结论

闭包用于私有变量、函数工厂、防抖节流、缓存(memoize)、模块模式、回调状态保持;把状态封装在函数内部,只暴露受控访问方法。

概念解释

  • 私有变量:外部无法直接访问,只能通过方法读写。
  • 工厂:按参数生成配置不同的函数。
  • 防抖节流:闭包保存定时器/上次时间戳。

原理流程

  1. 外层函数封装状态与方法。
  2. 返回内部方法暴露受控接口。
  3. 状态在闭包内持续维护。

代码 / 示例

// 防抖
function debounce(fn, delay) {
  let timer;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => fn(...args), delay);
  };
}

// 缓存
function memoize(fn) {
  const cache = new Map();
  return (key) => {
    if (!cache.has(key)) cache.set(key, fn(key));
    return cache.get(key);
  };
}

常见误区

  • 误区:闭包只能保存数字;正解:可保存任意类型状态,包括对象、定时器、DOM 引用。
  • 误区:防抖节流必须用类实现;正解:闭包工厂是最常见实现方式。

追问

  • Q:模块模式与 ESM 关系? A:闭包模块模式是 ESM 之前的封装手段,现代用模块作用域替代。
  • Q:缓存闭包会有什么内存问题? A:无界 Map 持续增长,需限制容量或 WeakMap 键。

03.2.1.3-010 循环里 setTimeout 为什么都打印同一个值?

一句话结论

var 声明的循环变量只有一个共享绑定,异步回调执行时循环已结束,读到的是最终值;let 每次迭代创建新绑定,回调捕获各自的值。

概念解释

  • var:函数作用域,i 被所有回调共享。
  • let:块级作用域,每轮迭代新绑定。
  • 历史方案:IIFE 立即传参生成闭包。

原理流程

  1. var 循环:绑定唯一,回调排队等待。
  2. 循环结束 i 为终值。
  3. 回调执行读到终值;let 方案每轮独立绑定。

代码 / 示例

// var:全部打印 3
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i));
}

// let:打印 0 1 2
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log(j));
}

// IIFE 老方案
for (var k = 0; k < 3; k++) {
  ((m) => setTimeout(() => console.log(m)))(k);
}

常见误区

  • 误区:setTimeout 延迟期间会复制 i;正解:回调引用同一绑定,不复制值。
  • 误区:把 var 改成 let 只是语法优化;正解:let 每轮新绑定是行为差异的关键。

追问

  • Q:forEach 回调里 var 有同样问题吗? A:forEach 每次迭代是独立函数调用,参数绑定独立,问题不同于 for 循环。
  • Q:异步拿到当前索引还有什么方式? A:回调参数传入索引值(IIFE/包裹函数),或 let 绑定。

03.2.1.3-011 IIFE 是什么?历史上解决什么问题?

一句话结论

IIFE(立即执行函数表达式)定义后立即调用,形成独立函数作用域,避免内部变量污染全局;在 let/const 与模块普及前,用于封装私有状态与避免冲突。

概念解释

  • 写法:(function(){})() 或 (function(){})()。
  • 内部变量外部不可见。
  • 可暴露接口到外部(模块模式)。

原理流程

  1. 函数表达式包裹作用域。
  2. 立即调用执行内部代码。
  3. 局部变量随调用结束被闭包/回收管理。

代码 / 示例

const counter = (function () {
  let n = 0;
  return { inc: () => ++n };
})();

常见误区

  • 误区:IIFE 主要用于异步;正解:它解决作用域隔离与全局污染,与异步无关。
  • 误区:现代项目还应大量使用 IIFE;正解:ESM 与块级作用域已替代其主要场景。

追问

  • Q:IIFE 内部能挂全局吗? A:可显式赋值到全局对象,默认局部变量不外泄。
  • Q:箭头函数能做 IIFE 吗? A:(() => {})() 可以,但可读性与兼容性按团队规范选择。

03.2.1.3-012 闭包在什么情况下不会释放,可能造成泄漏?

一句话结论

闭包引用的变量环境在闭包可达期间不释放;若闭包被长期持有(全局缓存、未解绑回调、定时器),且持有大对象/DOM 引用,就构成内存泄漏;不再需要时应解除引用。

概念解释

  • 可达性:闭包被全局/长生命周期结构引用。
  • 泄漏:本应回收的对象长期驻留。
  • 闭包本身不是泄漏,无界持有才是。

原理流程

  1. 闭包引用外部变量环境。
  2. 闭包被长生命周期结构持有。
  3. 变量环境不可回收,大对象驻留内存。

代码 / 示例

// 风险:全局缓存无界增长
const store = (() => {
  const data = new Map();
  return { set: (k, v) => data.set(k, v), clear: () => data.clear() };
})();

常见误区

  • 误区:用了闭包就一定内存泄漏;正解:闭包被正常短生命周期使用时,随引用消失回收。
  • 误区:闭包会复制所有外部变量;正解:只保留被引用的环境,未引用部分可回收。

追问

  • Q:事件监听器闭包泄漏怎么排查? A:移除监听、清理定时器,检查全局 Map/缓存是否持有 DOM 引用。
  • Q:WeakMap 为什么能缓解? A:键为弱引用,对象无其他引用时条目可被回收。

03.2.1.3-013 函数提升与变量提升有什么不同?

一句话结论

函数声明整体提升,函数体在定义前即可调用;var 只提升声明绑定(值为 undefined),赋值留在原位;函数表达式不提升。

概念解释

  • 函数声明:function f(){} 整体可用。
  • 变量:var 绑定先于赋值存在。
  • 表达式赋值给变量时,变量提升但函数体不提升。

原理流程

  1. 上下文创建扫描声明。
  2. 函数声明直接初始化函数对象。
  3. var 初始化为 undefined,执行到赋值再写入。

代码 / 示例

greet();            // "hi",函数声明提升
function greet() { console.log("hi"); }

console.log(fn);    // undefined
var fn = function () {};
// fn();            // 此处才可用

常见误区

  • 误区:函数表达式也能在定义前调用;正解:变量提升但值未赋值,调用报错。
  • 误区:函数提升覆盖同名 var;正解:提升顺序与冲突规则按规范,同名函数声明互相覆盖。

追问

  • Q:块内函数声明提升到哪里? A:历史行为有分歧,现代规范按块级处理,避免依赖跨块提升。
  • Q:为什么建议函数先声明后调用? A:减少提升带来的阅读歧义。

03.2.1.3-014 全局作用域与全局对象是什么关系?

一句话结论

全局作用域是最外层词法环境;浏览器全局对象为 window(Node 为 globalThis),var/函数声明挂到全局对象,let/const/类在全局作用域但不挂全局对象。

概念解释

  • 全局对象:全局属性与方法的载体。
  • 全局作用域 ≠ 全局对象:var 挂对象,let/const 不挂。
  • globalThis 提供跨环境全局对象引用。

原理流程

  1. 脚本顶层声明按规则归属。
  2. var/function 成为全局对象属性。
  3. let/const/class 存在全局词法环境,不挂对象。

代码 / 示例

var g = 1;
let l = 2;
window.g;     // 1
window.l;     // undefined
globalThis;   // 跨环境全局对象

常见误区

  • 误区:顶层 let 会成为 window 属性;正解:只有 var 与函数声明挂载全局对象。
  • 误区:全局变量一定挂全局对象;正解:区分词法全局绑定与全局对象属性。

追问

  • Q:为什么避免污染全局? A:命名冲突、意外覆盖、调试困难,模块作用域隔离。
  • Q:浏览器中 this 在全局默认是什么? A:非严格模式指向全局对象,严格模式为 undefined。

03.2.1.3-015 循环中 let 如何为每次迭代创建新绑定?

一句话结论

for 循环的 let 声明在每轮迭代创建一个新的词法绑定,上一轮绑定供本轮初始化使用;因此异步回调捕获各自迭代值,互不干扰。

概念解释

  • 每轮独立环境记录。
  • 本轮值由上一轮结果初始化。
  • 回调闭包绑定当轮变量。

原理流程

  1. 首轮创建绑定并初始化。
  2. 迭代结束保存本轮绑定供下轮初始化。
  3. 每轮新绑定被回调闭包引用。

代码 / 示例

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i)); // 0 1 2
}

常见误区

  • 误区:let 只是把 var 作用域改成块;正解:循环特有每轮新绑定机制,是回调拿到正确值的关键。
  • 误区:const 不能用于循环计数;正解:for(const x of arr) 每轮新绑定可用,for(const i=0;...) 自增会报错。

追问

  • Q:for...of 中 const 为什么合法? A:每轮迭代新绑定,不重新赋值已有绑定。
  • Q:迭代对象属性用 let 还是 const? A:不重新赋值用 const,需修改用 let。

03.2.1.3-016 嵌套作用域变量查找如何推演?

一句话结论

从当前作用域开始沿作用域链向外查找,内层同名变量遮蔽外层;先在当前环境记录命中即停止,未命中继续向外,全局仍未找到读取时抛 ReferenceError。

概念解释

  • 遮蔽:内层同名优先。
  • 查找只沿外层链,不进入兄弟/内层。
  • 赋值不查找遮蔽规则:默认写当前作用域。

原理流程

  1. 当前作用域查变量。
  2. 命中使用;未命中进入外层。
  3. 到全局仍缺失,读取报错。

代码 / 示例

const x = "global";
function a() {
  const x = "a";
  function b() {
    console.log(x); // "a":b → a 命中
  }
  b();
}
a();

常见误区

  • 误区:内层可以直接访问兄弟函数变量;正解:兄弟作用域不连通。
  • 误区:赋值时先查外层;正解:赋值默认在当前作用域建/写绑定,不向上查找遮蔽。

追问

  • Q:变量声明在使用之后怎么办? A:var 提升为 undefined,let/const 处 TDZ 报错。
  • Q:块内声明遮蔽函数级变量怎么判断? A:按最近块级作用域优先,阅读时从内向外追溯。

03.2.1.3-017 eval 与 with 如何影响作用域?为什么不推荐?

一句话结论

eval 执行参数字符串并在当前作用域解析声明,with 把对象属性加入作用域链;二者动态改变词法作用域,阻碍引擎优化且引入安全与可维护性问题,严格模式下受限。

概念解释

  • eval:字符串中的声明泄漏到调用作用域(非严格模式)。
  • with:对象属性作为作用域成员解析。
  • 风险:代码注入、难以静态分析、性能下降。

原理流程

  1. 动态代码在当前环境解析。
  2. 声明/属性进入作用域链。
  3. 引擎无法预编译优化,作用域不确定。

代码 / 示例

// 不推荐
eval("var secret = 1");
with (obj) { x = a; } // x 与 a 解析依赖 obj

常见误区

  • 误区:eval 只是动态执行字符串;正解:它还会改变作用域绑定,变量来源无法静态确认。
  • 误区:with 能缩短属性访问写法;正解:可读性与性能代价大于缩写收益。

追问

  • Q:严格模式 eval 行为? A:eval 内部声明不泄漏到外部作用域。
  • Q:动态取值替代方案? A:obj[key] 计算属性访问,不用 with/eval。

03.2.1.3-018 ESM 模块作用域有什么特点?

一句话结论

ES 模块有独立模块作用域,顶层变量不挂全局对象,导入导出通过静态绑定;模块内声明外部不可见,避免脚本间全局污染。

概念解释

  • 模块顶层 this 为 undefined(浏览器 ESM)。
  • 顶层声明私有于模块。
  • 导出绑定可被导入方引用,live binding。

原理流程

  1. 模块加载,建立独立环境。
  2. 顶层声明局限模块内。
  3. export 暴露绑定,import 建立引用。

代码 / 示例

// module.js
const secret = 1;
export const value = secret;

// main.js
import { value } from "./module.js";
// secret 不可访问

常见误区

  • 误区:ESM 顶层变量是全局变量;正解:模块作用域隔离,不挂 window。
  • 误区:模块内 var 会污染全局;正解:var 也只在模块作用域内。

追问

  • Q:模块作用域与闭包如何配合? A:模块内函数闭包引用模块私有变量,对外只暴露导出接口。
  • Q:CJS 模块作用域呢? A:CommonJS 函数包装形成模块作用域,exports 暴露接口,细节见 03.2.2.3。