稍候片刻,月出文自明。
console.log(typeof notDeclared); // 'undefined':未声明的标识符,typeof 不报错
console.log(typeof inTdz); // ReferenceError:TDZ 中的变量,typeof 也会抛错
let inTdz = 1;
sayHi(); // 正常执行:函数声明整体提升
function sayHi() { console.log('hi'); }
// 函数表达式则按变量规则处理
console.log(fn); // undefined
var fn = function () {};function createCounter() {
let count = 0; // 外部无法直接访问
return {
inc: () => ++count,
read: () => count,
};
}
const c = createCounter();
c.inc(); c.inc();
c.read(); // 2// 1) 循环中的 var:所有回调共享同一个 i
for (var i = 0; i < 3; i++) {
setTimeout(() => console.log(i)); // 3 3 3
}
// 改为 let:每轮独立绑定
for (let j = 0; j < 3; j++) {
setTimeout(() => console.log(j)); // 0 1 2
}
// 2) 闭包长期持有大对象
function attach() {
const huge = new Array(1e6).fill(0);
return () => huge.length; // 只要这个函数还在,huge 就不会被回收
}const obj = {
name: 'obj',
regular() { return this.name; }, // 'obj'
arrow: () => this?.name, // 取模块/全局的 this,与 obj 无关
};
const f = obj.regular;
f(); // 严格模式下 TypeError(this 为 undefined)
obj.regular(); // 'obj'
f.call({ name: 'x' }); // 'x'
obj.regular.bind({ name: 'y' })(); // 'y'
function Who() { return this; }
const bound = Who.bind({ tag: 'b' });
bound(); // { tag: 'b' }
new bound(); // 绑定被忽略,this 指向新实例function Person(name) { this.name = name; }
Person.prototype.greet = function () { return `Hi, ${this.name}`; };
const p = new Person('Ada');
p.greet(); // 'Hi, Ada'
Object.getPrototypeOf(p) === Person.prototype; // true
Object.getPrototypeOf(Person.prototype) === Object.prototype; // true
Object.getPrototypeOf(Object.prototype); // null:链条终点class Point {
#x = 0; // 私有字段
static origin = new Point(); // 静态字段
constructor(x) { this.#x = x; }
get x() { return this.#x; }
toString() { return `(${this.#x})`; }
}
Point.prototype.toString.call(new Point(1)); // '(1)'
Object.keys(new Point(1)); // []:#x 与原型方法都不在自身可枚举键里console.log('1');
setTimeout(() => console.log('2'));
Promise.resolve().then(() => console.log('3'));
queueMicrotask(() => console.log('4'));
console.log('5');
// 输出顺序:1 5 3 4 2Promise.resolve(1)
.then(v => v + 1) // 2
.then(v => { throw new Error('boom'); })
.catch(e => e.message) // 'boom'
.finally(() => console.log('done')); // 不影响结果,也不吞掉异常// 串行:总耗时是各任务之和
for (const task of tasks) {
await task();
}
// 并发:总耗时取决于最慢的那个
await Promise.all(tasks.map(t => t()));
// 并发但限制数量
async function mapLimit(items, limit, worker) {
const ret = [];
let cursor = 0;
const run = async () => {
while (cursor < items.length) {
const i = cursor++;
ret[i] = await worker(items[i]);
}
};
await Promise.all(Array.from({ length: Math.min(limit, items.length) }, run));
return ret;
}typeof null; // 'object':早期实现的遗留 bug
typeof function(){}; // 'function':函数有可调用性,单独归为一类
typeof 1n; // 'bigint'
typeof Symbol(); // 'symbol'
Object.prototype.toString.call(null); // '[object Null]'
Object.prototype.toString.call([]); // '[object Array]'
Object.prototype.toString.call(new Map()); // '[object Map]'0.1 + 0.2; // 0.30000000000000004
NaN === NaN; // false
Object.is(NaN, NaN); // true
Object.is(0, -0); // false
Number.MAX_SAFE_INTEGER; // 9007199254740991
Number.isSafeInteger(2 ** 53); // false
// 浮点比较应使用容差
Math.abs(a - b) < Number.EPSILON;[] + {}; // '[object Object]':两个都转成字符串后拼接
[] == false; // true:空数组转为 '',再转为 0
null == 0; // false:null 只与 undefined 宽松相等
'2' > '10'; // false:字符串比较是字典序,不是数值const o = {};
Object.defineProperty(o, 'x', { value: 1 });
Object.getOwnPropertyDescriptor(o, 'x');
// { value: 1, writable: false, enumerable: false, configurable: false }
Object.keys(o); // []:不可枚举const cfg = Object.freeze({ inner: { v: 1 } });
cfg.inner.v = 2; // 成功:freeze 只作用于第一层function* gen() {
const x = yield 1; // yield 既是出口也是入口
console.log(x);
}
const it = gen();
it.next(); // { value: 1, done: false }
it.next('hi'); // 打印 'hi' → { value: undefined, done: true }// counter.js
export let count = 0;
export function inc() { count++; }
// main.js
import { count, inc } from './counter.js';
console.log(count); // 0
inc();
console.log(count); // 1:读的是同一份绑定const meta = new WeakMap();
function annotate(el, data) {
meta.set(el, data); // el 被卸载并可回收时,这条记录随之消失
}const defaults = { theme: 'light' };
const settings = new Proxy(defaults, {
get(target, key, receiver) {
return key in target ? Reflect.get(target, key, receiver) : 'unknown';
},
set(target, key, value, receiver) {
console.log(`set ${String(key)} = ${value}`);
return Reflect.set(target, key, value, receiver); // 返回 true 表示成功
},
});
JavaScript 的难点往往不在语法本身,而在“运行时到底做了什么”:变量存在哪一层环境里、this 从哪里来、异步回调在什么时机执行、属性被哪些规则约束。这篇文章把进阶阶段最容易混淆、也最常被追问的知识点串成一条线,每个结论都配上能直接跑的代码,尽量做到准确可验证。
适合读者:已经能熟练写业务代码,想补齐运行时与规范细节,或者准备面试前系统过一遍的人。全文按“执行模型 → 对象模型 → 异步模型 → 语言细节”的顺序展开。
一、执行上下文与作用域:变量究竟存在哪里
每段代码运行前,引擎会为它创建执行上下文(execution context),其中包含词法环境、变量环境、this 绑定等信息。函数每被调用一次,就产生一个新的执行上下文,调用结束(且不再被闭包引用)后随之销毁。
关键结论是:作用域是静态的。它由代码的书写位置决定,与调用位置无关。这正是闭包能“记住”外部变量的根本原因,也是理解 this(动态绑定)与作用域(静态绑定)为何规则完全不同的前提。
进入上下文时会发生声明提升,但不同声明方式的初始化时机不同:
块级作用域还带来一个容易被忽略的行为:for (let i ...) 的每次迭代都会创建新的绑定并复制上一轮的值,所以循环里的回调能各自捕获到当次的值。换成 var 就只有一份共享绑定——这是最经典的闭包陷阱。
二、闭包:不只是“函数里套函数”
闭包是函数与其词法环境的组合。只要内部函数还可达,它引用的外部变量就不会被回收。常见用途:数据私有化、工厂函数、函数式组合、模块模式。
要注意的是:闭包本身不是内存泄漏,无法释放的引用才是。下面两个写法经常出现在真实的泄漏案例里:
“闭包一定导致变量常驻”也不准确。现代引擎会做上下文优化:只被单个闭包使用的变量有时会被分配到函数栈帧之外的独立存储,但这是实现细节,不能作为设计依据。判断标准只有一条——可达性。
三、this:五种绑定与优先级
this 在函数调用时确定(箭头函数除外),规则按优先级从高到低:
三个高频误区:方法被“借出去”后丢失 this(常见于把 obj.method 直接传给回调);DOM 事件监听器中普通函数的 this 是当前元素(currentTarget),箭头函数则不是;bind 返回新函数,不会修改原函数。
四、原型、原型链与 class
每个对象都有内部槽 [[Prototype]],用 Object.getPrototypeOf 读取,用 Object.setPrototypeOf 或 Object.create 设置(运行时修改原型会破坏引擎优化,除特殊场景外不要用)。函数对象额外拥有 prototype 属性,作为 new 创建的实例的原型。
属性查找沿原型链向上:自身 → 原型 → …… → Object.prototype → null。因此“读属性”可能来自原型,而“写属性”默认在自身创建(除非链上存在 setter)。
class 是原型继承的语法糖,但有几点实质差异:类体始终是严格模式;方法和访问器默认不可枚举;必须用 new 调用;类名在类体内部是常量;#private 字段是真正的私有槽,外部无法读写,也不在 Object.keys 中出现;类声明同样有 TDZ。
instanceof 检查构造函数的 prototype 是否位于对象的原型链上,跨 realm(如 iframe)会失效;可用 Symbol.hasInstance 自定义。跨 realm 判断数组请用 Array.isArray。
五、事件循环:微任务、宏任务与渲染时机
浏览器里,一次循环大致是:取出一个宏任务执行 → 清空微任务队列(包括执行过程中新加入的)→ 浏览器可能进行样式计算、布局与绘制。因此微任务会在下一次渲染之前全部跑完,宏任务之间才可能插入渲染。
Node.js 的循环按阶段推进(timers → pending callbacks → idle/prepare → poll → check(setImmediate) → close),每个回调结束后都会清空微任务;其中 process.nextTick 队列优先级高于 Promise 微任务队列,这一点与浏览器不同。
实践含义:一个超长的同步任务会阻塞渲染与输入响应;把大任务切片交给微任务并不能让出渲染机会(微任务会一次跑完),真正让页面喘气要靠宏任务或 requestIdleCallback / scheduler.postTask。
六、Promise 与 async/await 的准确姿势
Promise 一旦落定(fulfilled 或 rejected)就不可再变;then 返回新的 Promise,回调的返回值决定下一环状态,返回 thenable 会被展开。throw 等价于返回 rejected Promise。
组合方法的选择要准确:
关于 await 的两个细节值得记住:其一,await 一个非 Promise 值(如 await null)同样会把后续代码放进微任务,只是不产生额外延迟感;其二,串行与并发必须显式选择。
另外,async 函数总是返回 Promise;在 try/catch 之外使用 await 会得到未处理的 rejection,浏览器会触发 unhandledrejection 事件,Node 中默认会终止进程(可通过 process.on('unhandledRejection') 处理)。
七、类型系统的细节
原始类型共 7 种:undefined、null、boolean、number、string、symbol、bigint;其余都是对象。用 typeof 判断时有两处历史遗留需要注意:
number 是 IEEE 754 双精度浮点,安全整数范围到 2^53 - 1。由此产生的经典现象:
超过安全整数范围请用 BigInt:typeof 1n === 'bigint',它不能与 number 混合运算,除以 0n 会抛 RangeError,JSON.stringify 遇到它会直接抛 TypeError。
隐式转换仍然要小心。+ 会走 ToPrimitive(默认提示先 valueOf 后 toString),比较与数学运算走数值提示:
八、对象与属性的隐藏规则
属性描述符分两类:数据属性有 value / writable / enumerable / configurable;访问器属性用 get / set 替代前两个,因此不能再声明 value 或 writable。用 Object.defineProperty 定义时缺省值全为 false,而对象字面量创建的属性默认全为 true——这是很多“属性改不动、遍历不到”问题的来源。
三个“冻结”级别要区分清楚:Object.preventExtensions 只是禁止新增;Object.seal 再禁止删除与重新配置;Object.freeze 再把数据属性设为不可写。它们都是浅的:
拷贝也要分清深浅:展开运算符与 Object.assign 都是浅拷贝,只复制自身可枚举属性(包含 symbol 键),并且会触发 getter 求值;JSON 往返会丢掉 undefined、函数与 Symbol,把 Date 变成字符串、NaN 变成 null,遇到循环引用直接抛错;需要真正的深拷贝时用 structuredClone,它支持循环引用、Map/Set/Date,但不支持函数与 Symbol 值(抛 DataCloneError),自定义类的实例会退化成普通对象、丢失原型。
遍历时按目的选 API:Object.keys 取自身可枚举字符串键;for...in 会沿原型链枚举,几乎总应该配合 hasOwn;Reflect.ownKeys 返回全部自有键(含 symbol 与不可枚举)。
九、迭代器、生成器与可迭代协议
可迭代对象需要实现 [Symbol.iterator](),返回一个带 next() 的迭代器,next() 返回 { value, done }。for...of、展开、解构、Array.from 都依赖这套协议。
生成器函数的函数体在第一次 next() 时才执行;yield* 可把迭代委托给另一个可迭代对象;调用 it.return() 会提前结束并触发 finally。普通对象默认不可迭代,需要 Object.entries 或自行实现协议。
十、模块化:ESM 与 CommonJS
ESM 是静态的:导入必须在顶层、会被提升、支持 tree-shaking,导出是实时绑定而不是值拷贝;CJS 的 require 是运行时同步求值,按解析后的路径缓存,因此可以条件加载、也可以拿到循环依赖中的部分导出。
ESM 默认严格模式、有自己的顶层 this(为 undefined),浏览器中相对路径必须带扩展名,且脚本默认延迟执行;需要按需加载时用 import(),返回 Promise。Node 里通过 package.json 的 "type" 字段或 .mjs / .cjs 后缀区分两种格式。
十一、内存管理与常见泄漏
V8 以可达性判定存活,采用分代回收:新生代用 Scavenge(复制存活对象),老生代用标记-清除 + 标记-压缩。它不是引用计数,所以循环引用不会导致泄漏。
但当对象仍然“可达”却已经没用了,泄漏就发生了。高频来源:
缓存关联信息时优先用 WeakMap:键是弱引用,键对象被回收后条目自动消失。WeakRef 与 FinalizationRegistry 存在,但回收时机不确定,不应承载业务逻辑。
十二、Proxy 与 Reflect:元编程
Proxy 可以拦截对象的内部操作(get、set、has、deleteProperty、ownKeys、apply、construct 等)。Reflect 提供与这些 trap 一一对应的默认行为,并且返回布尔值而不是抛错,写 trap 时几乎是标配:
注意 trap 必须遵守规范的不变式(例如不可配置、不可写属性的 get 不能返回不同的值),否则会抛 TypeError;代理会带来额外调用开销,不要在全站热点路径上层层包装。Vue 3 的响应式正是基于 Proxy。
十三、现代语法里的坑
十四、易错点速查
十五、小结
把上面这些串起来,其实就是四句话:作用域是静态的,this 是动态的;对象的行为来自原型链,属性受描述符约束;同步代码一次跑完,异步的分层是宏任务 → 微任务 → 渲染;内存回收看可达性,而不是“有没有被引用过”。
真正把它们变成直觉的方式是动手验证:在控制台里跑一遍文中的每段代码,把输出和自己预期不一致的地方记下来,那才是最值得记住的部分。