MASTERY / 高阶篇

在语言深处,
与元编程相遇

高阶篇不再增加语法条目,而是拆开语言的运行机制:属性访问如何被拦截,迭代如何被协议驱动, 内存如何被判定为垃圾,框架的响应式与状态管理从何而来。读完之后,你应当能判断一段代码为什么快、 为什么慢,以及为什么可靠。

5 章 · 22 个知识点 3 个交互演示 前置:进阶篇 / 异步篇 阅读约 55 分钟
Chapter 01

元编程

让程序操作程序自身:用 Symbol 打开语言的隐藏接口,用 Proxy 与 Reflect 介入对象的基本操作,再亲手搭起一个最小的响应式系统。

1.1

Symbol 与知名符号

进阶

Symbol 是 ES6 引入的原始类型,每次调用 Symbol() 都返回一个全新且唯一的值,即使描述字符串完全相同。 它最常见的用途是作为对象的属性键,绕开字符串键的命名冲突;这类键不会出现在 for...in、 Object.keys 与 JSON.stringify 的结果里,因此适合存放库内部的元数据,也适合定义"半私有"的约定字段。 需要跨模块共享同一个 Symbol 时使用 Symbol.for(key),它走全局注册表,Symbol.keyFor 可以反查键名。

比自定义 Symbol 更重要的是知名符号(well-known symbols):语言内部会主动查找这些键。实现 Symbol.iterator 的对象可以被 for...of、展开运算符与解构消费; Symbol.toPrimitive 决定对象转原始值的规则,参数 hint 为 "number"、 "string" 或 "default";Symbol.toStringTag 影响 Object.prototype.toString 的输出,让 [object Object] 变成 [object Money]。 同族的还有 Symbol.hasInstance、Symbol.asyncIterator、Symbol.species 等。

工程视角上,知名符号是"实现协议"而不是"调用 API"。当你写一个自定义集合类时,实现 Symbol.iterator 比额外暴露一个 forEach 更符合语言习惯,因为它自动获得所有依赖迭代协议的能力。 需要注意:Symbol 不能 new,也不能隐式转字符串(Symbol() + '' 会抛 TypeError), 必须显式使用 String(sym) 或读取 sym.description。

const uid = Symbol('id');
const uid2 = Symbol('id');
console.log(uid === uid2);         // false,描述相同也互不相等
console.log(uid.toString());       // "Symbol(id)"

const user = { name: '林知远', [uid]: 'U-1024', age: 28 };
console.log(Object.keys(user));    // ["name", "age"],Symbol 键不出现
console.log(JSON.stringify(user)); // {"name":"林知远","age":28}

// Symbol.for 使用全局注册表,同名会复用同一个 Symbol
const g1 = Symbol.for('app.theme');
const g2 = Symbol.for('app.theme');
console.log(g1 === g2);            // true
console.log(Symbol.keyFor(g1));    // "app.theme"

// Symbol.toPrimitive:自定义对象转原始值的规则
const price = {
  amount: 128,
  [Symbol.toPrimitive](hint) {
    return hint === 'string' ? `¥${this.amount}` : this.amount;
  }
};
console.log(`${price}`);           // "¥128"
console.log(price + 2);            // 130

// Symbol.toStringTag:影响 Object.prototype.toString 的返回值
class Money {
  get [Symbol.toStringTag]() { return 'Money'; }
}
console.log(Object.prototype.toString.call(new Money())); // "[object Money]"

Symbol 键会被序列化丢弃。用 Symbol 存放的数据经过 JSON.stringify、 structuredClone 的 JSON 路径或网络传输后会消失,不要用它承载需要持久化的业务字段。

1.2

Proxy 拦截器

精通

Proxy 用 handler 中的陷阱函数接管对目标对象的基本操作,语法为 new Proxy(target, handler)。 get 与 set 最常用:get 在读取属性、访问方法时触发,set 在赋值时触发,二者都接收 (target, key, receiver)。receiver 通常指向代理本身, 因此内部要通过 Reflect.get(target, key, receiver) 转发,getter 与原型链上的访问才能保持正确语义。

除了读写,还有 has(in)、deleteProperty(delete)、 ownKeys(Object.keys 等)、getOwnPropertyDescriptor、 defineProperty、apply(函数调用)与 construct(new)。 每个陷阱都必须遵守不变量:不能对不可配置、不可写的属性返回不同的值,也不能在目标不可扩展时凭空报告新属性, 否则引擎会直接抛 TypeError。最稳妥的写法是"先校验,再用 Reflect 执行默认行为"。

Proxy 的代价是每次属性访问多一层函数调用,热路径上要谨慎;它也无法代理私有字段以及 Map、Set 的内部槽, 对这类对象应在外面包一层方法。删除代理只是解除引用,目标对象本身不受影响。

陷阱触发时机参数典型用途
get读取属性、访问方法target, key, receiver依赖收集、默认值、访问日志
set属性赋值target, key, value, receiver数据校验、触发更新
haskey in objtarget, key隐藏内部字段、权限判断
deletePropertydelete obj.keytarget, key保护必填字段
ownKeysObject.keys、for...intarget过滤敏感键
apply函数被调用target, thisArg, args参数校验、缓存、埋点
constructnew 调用target, args, newTarget单例、依赖注入
const user = { name: '林知远', age: 28 };

const proxy = new Proxy(user, {
  get(target, key, receiver) {
    if (!(key in target)) console.warn(`属性 ${String(key)} 不存在`);
    return Reflect.get(target, key, receiver);
  },
  set(target, key, value, receiver) {
    if (key === 'age' && (typeof value !== 'number' || value < 0)) {
      throw new TypeError('age 必须是非负数字');
    }
    return Reflect.set(target, key, value, receiver);
  },
  has(target, key) {
    return key.startsWith('_') ? false : key in target;
  },
  deleteProperty(target, key) {
    if (key === 'name') throw new Error('name 是必填字段,不能删除');
    return Reflect.deleteProperty(target, key);
  }
});

proxy.age = 30;
console.log(proxy.age);            // 30
try { proxy.age = -1; } catch (err) { console.log(err.message); }
delete proxy.age;
console.log('age' in proxy);       // false

// apply / construct:拦截函数调用与 new
function sum(a, b) { return a + b; }
const wrapped = new Proxy(sum, {
  apply(target, thisArg, args) {
    return Reflect.apply(target, thisArg, args) * 2;
  },
  construct(target, args) {
    return { total: Reflect.apply(target, null, args) };
  }
});
console.log(wrapped(1, 2));             // 6
console.log(new wrapped(3, 4).total);   // 7

为什么不能直接代理 Map。map.get 内部依赖 Map 的内部槽, 代理对象没有这些槽,调用会抛 TypeError: Method Map.prototype.get called on incompatible receiver。 正确做法是让 get 陷阱把方法绑定回原对象,或者干脆返回一个普通包装类。

1.3

Reflect 与默认行为

精通

Reflect 是一组函数式的对象操作,把语言内部的默认行为暴露出来: Reflect.get / set / has / deleteProperty / ownKeys / defineProperty / apply / construct。 它与对应的操作符行为一致,但以函数形式调用,并返回布尔值而非抛错。例如对冻结对象执行 Reflect.set 会返回 false,这让拦截器里的"执行默认行为"这一步变得可判断、可组合。

receiver 是 Reflect 最容易被忽略的参数。访问器属性执行时,getter 的 this 指向 receiver。若在代理的 get 中写成 target[key] 而不是 Reflect.get(target, key, receiver),getter 内部的 this 会指向原始对象, 代理就观察不到 getter 里的读取,依赖收集会漏掉这条依赖。

Reflect.ownKeys 返回包括 Symbol 与不可枚举属性在内的全部键,顺序遵循规范:整数键升序、字符串键按定义顺序、 Symbol 最后。写通用工具(深拷贝、序列化、拦截器)时优先使用 Reflect,可以少写许多 hasOwnProperty 与 try/catch 判断,也让默认行为只有一处来源。

const base = {
  _value: 1,
  get value() { return this._value * 10; }
};

const child = Object.create(base);
child._value = 5;
console.log(Reflect.get(base, 'value', child)); // 50,getter 的 this 是 child
console.log(base.value);                        // 10

// 在 Proxy 中透传 receiver,getter 才能拿到代理对象
const logged = new Proxy(child, {
  get(target, key, receiver) {
    const result = Reflect.get(target, key, receiver);
    console.log(`读取 ${String(key)} -> ${result}`);
    return result;
  }
});
logged.value;   // 先打印"读取 value -> 50"

// 冻结对象上赋值:Reflect.set 返回 false,而不是静默失败
const frozen = Object.freeze({ mode: 'readonly' });
console.log(Reflect.set(frozen, 'mode', 'edit')); // false

// ownKeys 包含不可枚举属性与 Symbol 键
const meta = Symbol('meta');
const record = { id: 1, [meta]: '内部标记' };
Object.defineProperty(record, 'hidden', { value: true, enumerable: false });
console.log(Reflect.ownKeys(record)); // ["id", "hidden", Symbol(meta)]

// Reflect.apply 不依赖函数自身的 apply 属性,避免被改写后失效
function greet(greeting) { return `${greeting},${this.name}`; }
console.log(Reflect.apply(greet, { name: '林知远' }, ['你好']));

Reflect 与 Object 的差异。Object.defineProperty 失败时抛错, Reflect.defineProperty 返回布尔值;Object.keys 只给可枚举字符串键, Reflect.ownKeys 给全部自有键。在代理陷阱内,Reflect 的返回值语义更容易衔接。

1.4

手写响应式系统

精通

Vue3 的响应式核心只有三件事:用 Proxy 拦截读写;用 WeakMap 记录"哪个对象的哪个属性被哪个副作用依赖"; 在写入时重新执行这些副作用。依赖表的结构是 WeakMap<target, Map<key, Set<effect>>>。 外层用 WeakMap,目标对象被回收时整张依赖表随之释放,不会拖住内存。

读取时把当前正在执行的 effect 收集进 Set;写入时取出该 key 对应的 Set 逐个执行。真实实现还要处理嵌套 effect (用栈保存父级 effect)、分支切换后的依赖清理、同一轮内去重触发(调度器),以及数组 length 与索引的联动。这里给出最小闭环,理解结构比记住 API 更重要。

下面的演示中输入单价或数量,setter 会把变化交给 trigger,total 文本随之更新,日志会记录触发的键与依赖数量。 可以观察两点:值没有真正变化时不会触发;一次赋值只通知依赖该键的 effect,而不是全部重算。

交互演示 · 依赖收集与触发Proxy + effect

依赖了 state 的 effect 会自动重算:合计 200 元

等待输入变化……
const targetMap = new WeakMap();
let activeEffect = null;
function track(target, key) {
  if (!activeEffect) return;
  let depsMap = targetMap.get(target);
  if (!depsMap) targetMap.set(target, (depsMap = new Map()));
  let dep = depsMap.get(key);
  if (!dep) depsMap.set(key, (dep = new Set()));
  dep.add(activeEffect);
}
function trigger(target, key) {
  const depsMap = targetMap.get(target);
  if (!depsMap) return;
  const dep = depsMap.get(key);
  if (dep) [...dep].forEach((effect) => effect());
}
function reactive(target) {
  return new Proxy(target, {
    get(obj, key, receiver) {
      track(obj, key);                       // 读取时收集依赖
      return Reflect.get(obj, key, receiver);
    },
    set(obj, key, value, receiver) {
      const oldValue = obj[key];
      const ok = Reflect.set(obj, key, value, receiver);
      if (ok && oldValue !== value) trigger(obj, key); // 变化才通知
      return ok;
    }
  });
}
function effect(fn) {
  activeEffect = fn;
  fn();                    // 首次执行,顺便完成依赖收集
  activeEffect = null;     // 及时清空,避免误收集
}

const state = reactive({ price: 100, count: 2 });
let total = 0;
effect(() => { total = state.price * state.count; });

console.log(total);        // 200
state.count = 3;
console.log(total);        // 300

先读再写。effect 首次执行必须真正读取属性,依赖才会被记录;如果计算函数提前 return, 后面分支用到的属性就不会被收集,这是响应式"更新不生效"的常见原因。

Chapter 02

迭代与生成器

协议先于语法:理解 next / value / done 的约定,才能看懂 for...of、展开与解构;而生成器把可暂停的计算变成一等对象。

2.1

迭代器协议与可迭代对象

进阶

迭代器协议规定对象提供一个 next() 方法,每次返回 { value, done };done 为 true 时,value 是最终返回值,通常被忽略。可迭代协议则要求对象拥有 Symbol.iterator 方法并返回迭代器。for...of 的执行过程是:先调用一次 Symbol.iterator 得到迭代器,然后反复调用 next,直到 done 为真; 循环体抛错或提前 break 时,会调用迭代器的 return() 做清理。

数组、字符串、Map、Set、arguments、NodeList 都是可迭代对象,普通对象不是。展开运算符、解构、 Array.from、Promise.all 都依赖迭代协议,所以自定义数据结构只要实现 Symbol.iterator,就自动获得这些能力。让迭代器同时实现 Symbol.iterator 并返回自身, 它就能被 for...of 消费,也能作为可迭代对象继续传递。

工程上要注意三点:迭代器通常是一次性的,消费完不会自动复位,而数组每次调用 Symbol.iterator 都会得到新迭代器;无限迭代器不能直接展开,必须配合 take 之类的限制; 迭代过程中修改集合,行为由实现决定,Map、Set 的迭代器会反映修改,数组则可能跳过元素。

const range = {
  from: 1,
  to: 5,
  [Symbol.iterator]() {
    let current = this.from;
    const last = this.to;
    return {
      next() {
        if (current <= last) return { value: current++, done: false };
        return { value: undefined, done: true };
      },
      // 迭代器自身也可迭代,便于被再次传递
      [Symbol.iterator]() { return this; }
    };
  }
};

console.log([...range]);            // [1, 2, 3, 4, 5]
const [first, second] = range;      // 解构同样走迭代协议
console.log(first, second);         // 1 2

let sum = 0;
for (const n of range) sum += n;
console.log(sum);                   // 15

// 迭代器是一次性的,再次消费需要新的迭代器
const iterator = range[Symbol.iterator]();
console.log(iterator.next());       // { value: 1, done: false }
console.log(iterator.next());       // { value: 2, done: false }

// 普通对象没有 Symbol.iterator,直接 for...of 会抛 TypeError
const plain = { a: 1, b: 2 };
console.log(typeof plain[Symbol.iterator]); // "undefined"

不要用 for...in 遍历可迭代数据结构。它遍历的是可枚举字符串键(包括原型链), 而顺序在数组上也不保证符合直觉。需要值时用 for...of,需要键值对时用 Object.entries。

2.2

生成器函数

精通

function* 声明的函数调用时不执行函数体,而是返回一个生成器对象;这个对象同时是迭代器与可迭代对象。 每次 next() 执行到下一个 yield 处暂停,把 yield 后的表达式作为 value 返回, done 为 false;再次调用时从暂停点继续,局部变量与执行位置都被保留。

next(value) 的参数会成为上一个 yield 表达式的返回值,这是生成器与外部双向通信的通道。 return(value) 让生成器立即以 done: true 结束,并执行 finally 块; throw(err) 把异常抛进暂停点,可以被生成器内部的 try/catch 捕获。 第一次 next 传入的参数会被忽略,因为此时还没有 yield 在等待接收。

生成器不能被 new 调用,箭头函数也不能写成生成器。它的价值在于把"可暂停的计算"变成一等对象: 惰性序列、状态机、协程调度都建立在这一点上。暂停与恢复由调用方控制,函数本身不决定何时继续。

function* counter(start = 0) {
  let step = 0;
  while (true) {
    // 暂停并返回值;received 是下一次 next 的实参
    const received = yield start + step;
    if (received === 'stop') return '结束';
    step += typeof received === 'number' ? received : 1;
  }
}

const gen = counter(10);
console.log(gen.next());        // { value: 10, done: false }
console.log(gen.next(2));       // { value: 12, done: false },step 变为 2
console.log(gen.next(3));       // { value: 15, done: false }
console.log(gen.next('stop'));  // { value: '结束', done: true }

// return 会提前结束生成器,但 finally 仍会执行
function* withCleanup() {
  try {
    yield 1;
    yield 2;
  } finally {
    console.log('清理资源');
  }
}

const task = withCleanup();
console.log(task.next());       // { value: 1, done: false }
console.log(task.return(9));    // 先打印"清理资源",再返回 { value: 9, done: true }

// throw 把异常注入暂停点,可被生成器内部捕获
function* guarded() {
  try {
    yield '等待中';
  } catch (err) {
    console.log('捕获:', err.message);
  }
}
const g = guarded();
g.next();
g.throw(new Error('外部中断'));  // 打印"捕获:外部中断"

生成器与普通迭代器的差别。普通迭代器需要手写状态变量,生成器由引擎保存执行上下文, 暂停点可以出现在任意表达式中间,包括 try 块内。恢复时不会重新执行整个函数,开销主要在上下文保存。

2.3

惰性序列与无限序列

精通

生成器的执行是惰性的:不调用 next 就不会计算。于是可以描述无限序列——斐波那契、自然数、事件流—— 只要消费端按需取用,内存占用就保持在常数级。这也是"用有限内存处理无限数据"的最直接写法。 yield* 能把另一个可迭代对象整体委托进来,适合拼接多段序列或把分页结果摊平。

分页加载是生成器的实用场景:把"请求下一页"写进 while 循环,取到空页或不足一页时结束, 调用方只看到一条连续序列,不必关心页码与游标。配合 take 限制数量,就能在不加载全量数据的前提下做预览、 搜索建议与增量渲染,首屏时间不受数据总量影响。

错误传播要提前设计:生成器内部抛错会终止迭代,for...of 会收到异常;如果生成器持有资源 (文件句柄、数据库游标),应放在 finally 中释放,因为消费端提前 break 时会调用 return()。分页示例里若 fetchPage 抛错,异常会直接冒泡到调用方。

// 无限斐波那契:只在需要时计算下一项
function* fibonacci() {
  let [a, b] = [0, 1];
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

function* take(iterable, n) {
  if (n <= 0) return;
  let count = 0;
  for (const value of iterable) {
    yield value;
    if (++count >= n) return;
  }
}

console.log([...take(fibonacci(), 10)]);
// [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

// 分页加载:把"拉取下一页"写成连续序列
function* paginate(fetchPage, pageSize = 2) {
  let page = 1;
  while (true) {
    const list = fetchPage(page, pageSize);
    if (!list.length) return;
    yield* list;                     // 委托内层数组逐项产出
    if (list.length < pageSize) return;
    page++;
  }
}

const fakeDB = ['A', 'B', 'C', 'D', 'E'];
const fetchPage = (page, size) => fakeDB.slice((page - 1) * size, page * size);
console.log([...take(paginate(fetchPage, 2), 3)]); // ["A", "B", "C"]

// 生成器同样可以被解构,此时只计算前两项
const [x, y] = fibonacci();
console.log(x, y);                 // 0 1

无限序列必须"限量出口"。把 take 作为唯一对外入口,而不是把无限生成器直接交给 [...gen] 或 Array.from(gen),否则页面会因为死循环而失去响应。

2.4

生成器与异步流程

精通

在 async/await 普及之前,社区用"生成器 + 自动执行器"实现同步写法:生成器 yield 出 Promise, runner 等待它 resolve,再通过 next(value) 把结果送回生成器;reject 则调用 gen.throw(err),让生成器内部的 try/catch 捕获。早期 co 库就是这一思路的成熟实现。

async/await 本质上是语言层面的语法糖:await 相当于 yield 一个 Promise 并由引擎自动驱动, await 之后的代码被放进微任务继续执行。理解这层对应关系能解释不少现象:为什么 await 暂停的是当前函数而不是主线程; 为什么 try/catch 能捕获 await 的拒绝;为什么在循环里 await 会串行,而 Promise.all 能并发。

今天写业务代码应优先使用 async/await,生成器更多出现在需要手动控制暂停与恢复的场合:状态机、流式解析、 可中断的任务编排。下面的 runner 只用于理解原理,生产环境不要重复造轮子,它缺少调度、取消与并发控制。

// 极简 runner:等待 yield 出来的 Promise,再把结果送回生成器
function run(generatorFn) {
  const gen = generatorFn();
  return new Promise((resolve, reject) => {
    function step(method, arg) {
      let result;
      try {
        result = gen[method](arg);
      } catch (err) {
        return reject(err);
      }
      if (result.done) return resolve(result.value);
      Promise.resolve(result.value).then(
        (value) => step('next', value),
        (err) => step('throw', err)
      );
    }
    step('next');
  });
}

function delay(ms, value) {
  return new Promise((resolve) => setTimeout(() => resolve(value), ms));
}

function* fetchProfile() {
  const user = yield delay(50, { id: 1, name: '林知远' });
  try {
    const posts = yield delay(50, ['第一篇', '第二篇']);
    return { user, posts };
  } catch (err) {
    return { error: err.message };   // await 的拒绝会走到这里
  }
}

run(fetchProfile).then((data) => console.log(data));
// { user: { id: 1, name: '林知远' }, posts: ['第一篇', '第二篇'] }

对应的写法。把 yield 换成 await、去掉 runner, 就是今天的 async function fetchProfile()。Babel 早期转译 async 函数时, 生成的正是基于生成器与状态机的代码。

Chapter 03

性能与内存

性能不是玄学:先测准,再优化。理解主线程、渲染管线与可达性,才能判断瓶颈在计算、在布局,还是在内存。

3.1

性能测量

进阶

performance.now() 返回从页面导航开始的高精度时间戳(毫秒,带小数),单调递增,不受系统时钟调整影响, 适合测量耗时;Date.now() 精度低且可能回拨。测量时应先预热,让 JIT 完成优化,再重复多次取中位数, 否则单次结果波动很大,容易得出错误结论。

console.time / timeEnd 适合临时打点;performance.mark / measure 会把标记写入性能时间线, 能在 DevTools 的 Performance 面板中看到同名区块,也可以被 PerformanceObserver 采集后上报到监控系统。 getEntriesByName 可以取回测量结果,做自动化对比。

长任务(long task)指占用主线程超过 50ms 的任务,期间无法响应输入、无法渲染,是卡顿的直接来源。 用 PerformanceObserver 监听 longtask 能定位到具体时间段,再配合自定义 measure 对上业务区间。 注意 longtask 观察并非所有浏览器都支持,代码要容错,且上报本身要轻量。

const t0 = performance.now();
let sum = 0;
for (let i = 0; i < 1e6; i++) sum += i;
const t1 = performance.now();
console.log(`循环耗时 ${(t1 - t0).toFixed(2)} ms`);

// 标记与测量:性能面板中会出现同名区块
performance.mark('render:start');
document.body.dataset.ready = '1';
performance.mark('render:end');
performance.measure('render', 'render:start', 'render:end');
const measure = performance.getEntriesByName('render')[0];
console.log(`渲染区间 ${measure.duration.toFixed(2)} ms`);

// 长任务观察:超过 50ms 的任务会阻塞交互
if ('PerformanceObserver' in window) {
  try {
    const observer = new PerformanceObserver((list) => {
      for (const entry of list.getEntries()) {
        console.warn(`长任务 ${entry.duration.toFixed(0)}ms`, entry);
      }
    });
    observer.observe({ type: 'longtask', buffered: true });
  } catch (err) {
    console.log('当前浏览器不支持 longtask 观察');
  }
}

// 简单基准:多次运行取中位数,避免单次抖动误导
function benchmark(fn, times = 5) {
  const samples = [];
  for (let i = 0; i < times; i++) {
    const start = performance.now();
    fn();
    samples.push(performance.now() - start);
  }
  samples.sort((a, b) => a - b);
  return samples[Math.floor(samples.length / 2)];
}
console.log(benchmark(() => Array.from({ length: 10000 }, (_, i) => i * 2)));

不要用一次测量下结论。浏览器会做 JIT 优化、GC 与后台任务调度,同一个函数的耗时会浮动数倍。 至少运行 5 次,关注中位数与离群值,并在接近真实设备的机器上验证。

3.2

防抖与节流

进阶

防抖(debounce)把短时间内的多次调用合并成最后一次(或第一次),核心是每次触发都重置定时器; 节流(throttle)保证单位时间内最多执行一次,核心是记录上次执行时间,或维持一个待执行的定时器。 两者都不减少事件本身的触发次数,只减少处理函数的执行次数。

选择取决于语义:搜索联想、表单校验、窗口 resize 结束后的重排,适合防抖,因为用户"停下来"才需要结果; 滚动进度、拖拽位置、埋点上报,适合节流,因为需要过程性的均匀采样。按钮提交更适合"立即执行 + 冷却"的节流, 防止连续点击产生重复订单。

实现细节决定可靠性:必须用 apply 保留 this 与参数;防抖应提供 cancel 以便组件卸载时清理;节流要处理最后一次调用,否则滚动停止时位置会停在中途。 在 React 等框架中,回调每次渲染都会重建,需要用 ref 或 useMemo 固定包装后的函数。

维度防抖 debounce节流 throttle
执行时机连续触发结束后(或首次)固定间隔内最多一次
触发频率与触发密度无关,只执行一轮被频率上限约束,均匀采样
典型场景搜索输入、表单校验、resize 结束滚动监听、拖拽、埋点、按钮冷却
首帧响应默认延迟,需 leading 选项默认立即执行一次
必要能力cancel / flushtrailing 补发、cancel
交互演示 · 同一事件,两种节奏window 300ms

防抖 debounce

输入事件 0 次,实际处理 0 次。停止输入 300ms 后才执行。

节流 throttle

输入事件 0 次,实际处理 0 次。每 300ms 最多执行一次。

等待输入……
function debounce(fn, wait = 300, { leading = false } = {}) {
  let timer = null;
  function debounced(...args) {
    if (leading && !timer) fn.apply(this, args);   // 前沿触发
    clearTimeout(timer);
    timer = setTimeout(() => {
      timer = null;
      if (!leading) fn.apply(this, args);          // 后沿触发
    }, wait);
  }
  debounced.cancel = () => { clearTimeout(timer); timer = null; };
  return debounced;
}

function throttle(fn, interval = 200) {
  let last = 0;
  let timer = null;
  let lastArgs = null;
  let lastThis = null;
  function throttled(...args) {
    const now = Date.now();
    const remaining = interval - (now - last);
    lastArgs = args;
    lastThis = this;
    if (remaining <= 0) {
      if (timer) { clearTimeout(timer); timer = null; }
      last = now;
      fn.apply(lastThis, lastArgs);
    } else if (!timer) {
      timer = setTimeout(() => {
        last = Date.now();
        timer = null;
        fn.apply(lastThis, lastArgs);   // 补发最后一次调用
      }, remaining);
    }
  }
  throttled.cancel = () => { clearTimeout(timer); timer = null; last = 0; };
  return throttled;
}

const onSearch = debounce((keyword) => console.log('请求搜索:', keyword), 300);
onSearch('元编程');
onSearch('元编程入');
onSearch('元编程入门');   // 只有这一次真正执行

组件卸载要 cancel。防抖定时器持有回调与参数,若组件已经销毁而定时器仍存活, 回调可能访问失效的 DOM 或状态。在 useEffect 的清理函数或自定义元素的 disconnectedCallback 中调用 cancel()。

3.3

渲染优化:虚拟列表与分片

精通

浏览器渲染一帧大致经过:JS 执行、样式计算、布局、绘制、合成。读取 offsetTop、 getBoundingClientRect、scrollHeight 等属性会强制浏览器立即完成布局; 如果在循环里"读—写—读",就会反复触发布局,这就是布局抖动。正确做法是把需要读的值集中读完,再统一写入 DOM。

虚拟列表只渲染视口内的若干行,用上下两个占位元素撑起总高度,滚动时按 scrollTop 计算可见区间并替换内容。收益与"总条数 ÷ 可见条数"成正比,代价是需要固定行高(或自行测量并缓存), 以及处理快速滚动时的空白与更新节流。

分片渲染把大任务拆成小批,借助 requestAnimationFrame 或 requestIdleCallback 在帧间让出主线程。requestIdleCallback 提供 timeRemaining(),适合低优先级工作, 但它可能被无限推迟,必须设置 timeout 兜底。动画优先使用 transform 与 opacity, 它们可以只走合成层,不触发布局与重绘。

// 虚拟列表核心:根据滚动位置计算需要渲染的区间
const ITEM_HEIGHT = 32;
const BUFFER = 3;   // 视口上下各多渲染几行,减少快速滚动时的空白
function getVisibleRange(scrollTop, viewportHeight, total) {
  const start = Math.max(0, Math.floor(scrollTop / ITEM_HEIGHT) - BUFFER);
  const count = Math.ceil(viewportHeight / ITEM_HEIGHT) + BUFFER * 2;
  return { start, end: Math.min(total, start + count) };
}

console.log(getVisibleRange(0, 300, 10000));    // { start: 0, end: 16 }
console.log(getVisibleRange(3200, 300, 10000)); // { start: 97, end: 113 }
// 上下占位元素撑起总高度,滚动条比例才正确
function renderWindow(container, total, range) {
  const frag = document.createDocumentFragment();
  const topSpacer = document.createElement('div');
  topSpacer.style.height = `${range.start * ITEM_HEIGHT}px`;
  frag.appendChild(topSpacer);

  for (let i = range.start; i < range.end; i++) {
    const row = document.createElement('div');
    row.style.height = `${ITEM_HEIGHT}px`;
    row.textContent = `第 ${i + 1} 条记录`;
    frag.appendChild(row);
  }
  const bottomSpacer = document.createElement('div');
  bottomSpacer.style.height = `${(total - range.end) * ITEM_HEIGHT}px`;
  frag.appendChild(bottomSpacer);

  // 一次性替换,只触发一次重排
  container.replaceChildren(frag);
}

// 滚动事件里只做计算,渲染交给 rAF,避免每个 scroll 都重排
const viewport = document.querySelector('#virtualViewport');
let ticking = false;
if (viewport) {
  viewport.addEventListener('scroll', () => {
    if (ticking) return;
    ticking = true;
    requestAnimationFrame(() => {
      ticking = false;
      renderWindow(viewport, 10000, getVisibleRange(viewport.scrollTop, viewport.clientHeight, 10000));
    });
  }, { passive: true });
}

现代 CSS 的两个补充。content-visibility: auto 让视口外的区块跳过布局与绘制, contain: layout paint 限制重排影响范围。它们不能替代虚拟列表,但在长文档与卡片流里成本极低、收益明显。

3.4

内存管理与泄漏

精通

GC 判断对象是否存活的标准是可达性:从根(全局对象、当前调用栈、DOM 树等)出发,能否沿着引用链找到它。 闭包会延长外层变量的生命周期;被移除的 DOM 节点如果仍被 JS 变量引用,也不会被回收,称为 detached DOM。 "手动置为 null"只在确实切断最后一条引用时才有意义。

常见泄漏有五类:未清理的定时器与事件监听、闭包意外持有大对象、无上限增长的缓存、detached DOM 引用、 意外的全局变量(未声明赋值、回调里的 this 指向 window)。单页应用还要注意路由切换时未解绑的订阅, 以及被遗忘的 IntersectionObserver 与 ResizeObserver。

WeakMap 与 WeakSet 的键是弱引用:键对象没有其他引用时,条目自动消失,且不可枚举、不可遍历。 它们适合给对象挂载元数据、做对象级缓存、标记已处理对象。WeakRef 与 FinalizationRegistry 提供更细的控制, 但执行时机依赖 GC,不应承载业务逻辑。

泄漏场景典型写法表现处理方式
定时器 / 轮询setInterval 引用组件状态组件卸载后仍在跑保存 id,卸载时 clear
全局事件监听window.addEventListener 不解绑每次挂载多一份回调使用 AbortController 或 off
detached DOM数组缓存已移除的节点Dom 节点数持续增长及时清空引用
无界缓存Map 只写不删堆内存单调上升LRU + 上限,或 WeakMap
闭包持有大对象回调引用整份响应数据快照里保留大 ArrayBuffer只捕获必要字段
意外全局变量非严格模式下的隐式赋值变量永不释放开启 strict、使用 let/const
// WeakMap:以对象为键,键被回收后条目自动消失,适合挂载私有数据
const privateData = new WeakMap();

class Session {
  constructor(user) {
    privateData.set(this, {
      user,
      token: 'tk_' + Math.random().toString(36).slice(2)
    });
  }
  get token() { return privateData.get(this).token; }
}

let session = new Session({ name: '林知远' });
console.log(session.token.startsWith('tk_')); // true
session = null;   // 无其他引用后,实例与 WeakMap 条目可一起回收

// 典型泄漏:定时器持有元素引用,销毁时必须显式清理
function createTicker(el) {
  const timer = setInterval(() => {
    el.textContent = new Date().toLocaleTimeString();
  }, 1000);
  return () => clearInterval(timer);   // 返回销毁函数,而不是让调用方猜
}

const clock = document.createElement('div');
const stopTicker = createTicker(clock);
// 组件卸载时调用 stopTicker(),否则 clock 与闭包会一直被引用

// WeakSet 适合做"已处理"标记,不阻止对象被回收
const visited = new WeakSet();
function markOnce(node) {
  if (visited.has(node)) return false;
  visited.add(node);
  return true;
}
const node = {};
console.log(markOnce(node), markOnce(node)); // true false

排查顺序。打开 DevTools 的 Memory 面板,连续拍两张堆快照,对比"新增对象"; 用 Allocation instrumentation on timeline 观察分配峰值;在 Elements 面板搜索 detached 节点。 先确认泄漏存在,再定位引用链,不要凭直觉改代码。

3.5

代码分割与懒加载

进阶

静态 import 会在模块图解析阶段就加载并执行依赖,首屏用不到的重模块会挤占带宽与主线程。 动态 import() 返回 Promise,打包器据此做代码分割,把目标模块拆成独立 chunk, 在真正调用时才下载与执行,页面启动成本因此与首屏所需代码量挂钩,而不是与项目总量挂钩。

拆分粒度按"路由 + 交互"设计:路由级拆分保证首屏只加载当前页面;交互级拆分把编辑器、图表、地图等重组件 推迟到用户点击时。拆分过细会产生大量小请求与瀑布式加载,反而更慢,通常以 20–50KB 为参考下限, 并结合打包分析工具观察实际产物。

加载体验要设计:先渲染骨架或占位,失败时给出重试入口;同一模块的 import() 结果会被缓存, 重复调用不会重复下载。preload 用于当前页面即将需要的资源,prefetch 用于下一个页面可能需要的资源,二者都只是提示,浏览器可以忽略。

// 按需加载:打包器会把 chart.js 拆成独立 chunk
async function openChart(container) {
  try {
    container.textContent = '图表模块加载中…';
    const { renderChart } = await import('./modules/chart.js');
    renderChart(container);
  } catch (err) {
    container.textContent = '图表加载失败,请稍后重试';
    console.error('[chart] 加载失败', err);
  }
}

// 交互级懒加载:用户点击时才下载
const trigger = document.querySelector('#loadChart');
if (trigger) {
  trigger.addEventListener('click', () => {
    openChart(trigger.parentElement);
  });
}

// 路由级懒加载:切换页面时再取模块
async function loadRoute(name) {
  const routes = {
    dashboard: () => import('./pages/dashboard.js'),
    settings: () => import('./pages/settings.js')
  };
  const loader = routes[name];
  if (!loader) throw new Error(`未知路由:${name}`);
  const module = await loader();
  return module.default;
}

// 空闲时预取下一个页面可能用到的资源
function prefetchOnIdle(url) {
  const add = () => {
    const link = document.createElement('link');
    link.rel = 'prefetch';
    link.href = url;
    document.head.appendChild(link);
  };
  if ('requestIdleCallback' in window) requestIdleCallback(add, { timeout: 3000 });
  else setTimeout(add, 1500);
}
prefetchOnIdle('./pages/settings.js');

懒加载要有失败路径。用户可能处于弱网或公司内网,chunk 请求失败会抛 ChunkLoadError。捕获后提示重试,必要时引导刷新页面,旧版本资源被清理时尤其常见。

Chapter 04

编程范式与设计模式

模式不是模板,而是对变化点的回应。纯函数、事件解耦、策略查表与高阶包装,解决的是同一件事:让改动只发生在一处。

4.1

函数式编程基础

进阶

纯函数指相同输入必得相同输出、且不修改外部状态的函数。它让代码可缓存、可测试、可并行。副作用(请求、日志、 DOM 操作、随机数)不是敌人,而是必须被隔离到边界上:核心计算保持纯净,副作用集中在适配层, 这样业务规则才能脱离环境被验证。

不可变数据是函数式的配套约束:不直接修改原对象,而是返回新对象。展开运算符做浅拷贝,嵌套结构要逐层展开; structuredClone 可以做深拷贝,但不支持函数与 DOM 节点。不可变的收益是可预测的状态变更与廉价比较, 代价是内存与拷贝开销,实践中常配合结构共享的数据结构。

组合(compose)从右到左、管道(pipe)从左到右,把多个一元函数串成数据流;柯里化把多元函数变成一元函数链, 便于预设参数、复用中间结果。注意柯里化依赖 fn.length,带默认值或剩余参数时长度不可靠; 过度 point-free 会牺牲可读性与错误堆栈。

交互演示 · 柯里化与管道实时计算
/posts/hello-javascript-world
trim toLowerCase replace 空格 加前缀
// 纯函数:输出只由输入决定,不修改外部状态
const addItem = (list, item) => [...list, item];

// 柯里化:把多参函数拆成单参函数链,便于复用
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) return fn.apply(this, args);
    return (...rest) => curried.apply(this, [...args, ...rest]);
  };
}

const multiply = curry((a, b, c) => a * b * c);
console.log(multiply(2)(3)(4));   // 24
console.log(multiply(2, 3)(4));   // 24

// 管道:从左到右执行,数据流方向与阅读方向一致
const pipe = (...fns) => (input) => fns.reduce((acc, fn) => fn(acc), input);

const normalize = (s) => s.trim().toLowerCase();
const toSlug = (s) => s.replace(/\s+/g, '-');
const withPrefix = (s) => `/posts/${s}`;

const toPostUrl = pipe(normalize, toSlug, withPrefix);
console.log(toPostUrl('  Hello JavaScript World  '));
// "/posts/hello-javascript-world"

// 不可变更新:返回新对象,原状态保持不变
const state = { user: { name: '林知远', tags: ['js'] } };
const next = {
  ...state,
  user: { ...state.user, tags: [...state.user.tags, 'ts'] }
};
console.log(state.user.tags.length, next.user.tags.length); // 1 2

柯里化不是万能包装。带默认参数时 fn.length 只统计默认值之前的参数个数, curry((a, b = 1) => a + b) 会在第一个参数后就执行。需要精细控制时,直接写接受配置的工厂函数更清楚。

4.2

发布订阅与 EventEmitter

精通

发布订阅用一个事件中心解耦生产者与消费者:生产者只管 emit,消费者只管 on, 双方不持有对方引用。它与 DOM 事件模型相似,但没有冒泡与捕获,是纯内存实现,常用于跨组件通信、 插件系统与状态通知。

实现要点:用 Map<type, Set<handler>> 存储,Set 天然去重;on 返回取消函数,调用方不必记住 off 的参数;once 通过包装函数实现,触发前先解绑; emit 前复制订阅者列表,避免回调内部增删导致遍历异常。

错误隔离是生产实现与玩具实现的分水岭:一个订阅者抛错不应阻断其他订阅者,也不应让 emit 的调用方崩溃, 通常逐个 try/catch 并上报。另一个隐患是内存泄漏:组件销毁时必须解绑,否则事件中心会一直持有组件引用。

class EventEmitter {
  constructor() { this.events = new Map(); }

  on(type, handler) {
    if (!this.events.has(type)) this.events.set(type, new Set());
    this.events.get(type).add(handler);
    return () => this.off(type, handler);   // 返回取消订阅函数
  }
  off(type, handler) {
    const set = this.events.get(type);
    if (set) set.delete(handler);
  }

  once(type, handler) {
    const wrapper = (...args) => {
      this.off(type, wrapper);
      handler(...args);
    };
    return this.on(type, wrapper);
  }

  emit(type, ...args) {
    const set = this.events.get(type);
    if (!set) return 0;
    // 复制一份再遍历:回调内部增删订阅不影响本次分发
    [...set].forEach((handler) => {
      try {
        handler(...args);
      } catch (err) {
        console.error(`[EventEmitter] "${type}" 订阅者异常:`, err);
      }
    });
    return set.size;
  }
}

const bus = new EventEmitter();
const off = bus.on('save', (id) => console.log('订阅 A', id));
bus.once('save', (id) => console.log('只执行一次', id));
bus.on('save', () => { throw new Error('故意失败'); });

bus.emit('save', 1);   // 订阅 A / 只执行一次 / 错误被隔离
bus.emit('save', 2);   // 订阅 A / 错误被隔离
off();
console.log(bus.emit('save', 3)); // 1

命名空间能省很多解绑工作。让 on 支持传入 owner(组件实例), offAll(owner) 在卸载时一次性清空该组件的全部订阅,比逐个记住取消函数更不容易漏。

4.3

单例、工厂与策略模式

进阶

单例保证一个类只有一个实例并提供全局访问点,适合配置中心、连接池、日志器。实现要点是私有构造、懒初始化, JS 单线程下初始化是同步的,不存在竞态。全局状态过多会让测试互相污染,因此应控制单例数量, 并在测试中使用重置入口。

工厂把创建逻辑集中起来,调用方只传类型或参数,不关心具体类与初始化细节,适合渠道适配、组件注册表、 按配置选择实现。策略模式把可替换算法抽成独立函数或对象,用查表替代分支;新增策略时不修改调用方, 符合开闭原则。

三者经常组合:工厂返回策略对象,单例管理注册表。是否需要模式的标准是"变化点是否已经出现", 而不是"模式是否优雅";两三个分支就用 if/else 更清楚,过早抽象会让代码多一层跳跃。

模式解决的问题结构要点常见误用
单例全局唯一、共享状态私有构造、懒初始化、统一入口把可变状态到处塞,测试互相污染
工厂创建逻辑与使用解耦类型 → 构造函数的映射表只是包一层 new,没有新增能力
策略替换算法、消除分支key → 函数/对象,运行时选择策略只差一个参数,拆得过碎
// 单例:全局唯一的配置中心
class AppConfig {
  static #instance = null;
  static getInstance() {
    if (!AppConfig.#instance) AppConfig.#instance = new AppConfig();
    return AppConfig.#instance;
  }
  constructor() {
    if (AppConfig.#instance) throw new Error('请使用 AppConfig.getInstance()');
    this.values = new Map();
  }
  set(key, value) { this.values.set(key, value); return this; }
  get(key) { return this.values.get(key); }
}

// 工厂:按渠道类型创建实例,调用方不关心构造细节
const channels = {
  alipay: () => ({ name: '支付宝', pay: (amount) => `支付宝支付 ${amount} 元` }),
  wechat: () => ({ name: '微信支付', pay: (amount) => `微信支付 ${amount} 元` })
};
function createChannel(type) {
  const factory = channels[type];
  if (!factory) throw new Error(`未知支付渠道:${type}`);
  return factory();
}

// 策略:把算法抽成可替换的函数,用查表代替 if/else
const shippingStrategies = {
  standard: (weight) => 8 + weight * 1.5,
  express: (weight) => 18 + weight * 3,
  free: () => 0
};
function calcShipping(type, weight) {
  const strategy = shippingStrategies[type] || shippingStrategies.standard;
  return strategy(weight);
}

const config = AppConfig.getInstance();
config.set('currency', 'CNY');
console.log(config.get('currency'));           // "CNY"
console.log(createChannel('wechat').pay(66));  // "微信支付 66 元"
console.log(calcShipping('express', 2));       // 24
console.log(calcShipping('unknown', 2));       // 11,回退到标准策略

策略表的工程细节。表驱动写法要定义"未知 key"的默认策略,否则线上配置拼写错误会直接抛错。 若策略需要共享状态,用对象方法而不是箭头函数,避免 this 指向丢失。

4.4

装饰器与函数包装

精通

装饰器模式指在不修改原函数的前提下,包裹出新函数来附加行为:日志、缓存、重试、权限校验、性能计时。 JavaScript 里用高阶函数实现,不依赖实验性的 @decorator 语法,兼容性最好,也更容易组合。

memoize 用参数生成缓存键;参数含对象时 JSON.stringify 会丢失函数、Symbol 与 undefined,且键的顺序敏感,因此最好传入自定义 resolver,或用 WeakMap 按对象身份缓存。 日志装饰器要保留 this、参数与返回值,异步函数还要在 finally 中统计耗时。

重试装饰器只适用于幂等操作,必须限制次数并采用指数退避加抖动,否则会在故障时形成重试风暴。 多个装饰器叠加时顺序很重要:withLog(memoize(fn)) 会记录每次调用(包括命中缓存), memoize(withLog(fn)) 则只记录真正计算的那一次。

// memoize:用参数生成缓存键,适合纯函数与重复计算
function memoize(fn, resolver = (...args) => JSON.stringify(args)) {
  const cache = new Map();
  return function (...args) {
    const key = resolver.apply(this, args);
    if (cache.has(key)) return cache.get(key);
    const result = fn.apply(this, args);
    cache.set(key, result);
    return result;
  };
}
// 日志装饰器:不改变原函数的签名与返回值
function withLog(fn, label = fn.name || 'anonymous') {
  return function (...args) {
    console.log(`[${label}] 调用,参数:`, args);
    const start = performance.now();
    try {
      return fn.apply(this, args);
    } finally {
      console.log(`[${label}] 耗时 ${(performance.now() - start).toFixed(2)}ms`);
    }
  };
}

// 重试装饰器:只对异步函数生效,指数退避
function withRetry(fn, retries = 3, baseDelay = 100) {
  return async function (...args) {
    let lastError;
    for (let attempt = 0; attempt <= retries; attempt++) {
      try {
        return await fn.apply(this, args);
      } catch (err) {
        lastError = err;
        if (attempt === retries) break;
        const delay = baseDelay * 2 ** attempt + Math.random() * 50;
        await new Promise((resolve) => setTimeout(resolve, delay));
      }
    }
    throw lastError;
  };
}

const square = withLog(memoize((n) => n * n), 'square');
console.log(square(12));   // 首次计算,打印参数与耗时
console.log(square(12));   // 命中缓存,仍然有日志,但不再计算

缓存要有失效策略。用 Map 做 memoize 会让结果永久驻留,参数空间大时等同于内存泄漏。 生产实现应加上限(LRU)或 TTL,并在数据源变化时主动清空。

4.5

错误处理体系

精通

自定义错误应继承 Error,并设置 name、code 与 cause。 ES6 class 已自动修正原型链,instanceof 可以正常工作;cause 能保留底层异常, 便于日志串联。业务错误与程序错误要分开:前者可预期、可提示用户,后者应快速失败并上报。

错误边界的思想是"在合适的层级捕获,避免整棵树崩溃"。原生 JS 没有组件边界,但可以用统一的请求封装、 模块入口的 try/catch 模拟;框架层的 componentDidCatch 只是把这套思路组件化, 它也不能捕获事件回调与异步代码里的错误。

全局兜底分两类:window 的 error 事件捕获同步脚本错误与资源加载失败(资源错误不冒泡, 需要捕获阶段),unhandledrejection 捕获未处理的 Promise 拒绝。兜底只用于上报与降级, 不能替代局部处理;吞掉错误而不记录,比直接崩溃更难排查。

class AppError extends Error {
  constructor(message, { code = 'APP_ERROR', cause, context } = {}) {
    super(message, { cause });
    this.name = 'AppError';
    this.code = code;
    this.context = context;
  }
}

class NetworkError extends AppError {
  constructor(message, options = {}) {
    super(message, { code: 'NETWORK_ERROR', ...options });
    this.name = 'NetworkError';
  }
}

async function request(url) {
  try {
    const res = await fetch(url);
    if (!res.ok) throw new NetworkError(`HTTP ${res.status}`, { context: { url } });
    return await res.json();
  } catch (err) {
    if (err instanceof NetworkError) throw err;
    throw new NetworkError('网络请求失败', { cause: err, context: { url } });
  }
}

// 全局兜底:脚本错误与未处理的 Promise 拒绝分开监听
window.addEventListener('error', (event) => {
  // 资源加载失败不冒泡,需要在捕获阶段监听才能拿到 target
  console.error('[global error]', event.message || event.target, event.filename, event.lineno);
}, true);

window.addEventListener('unhandledrejection', (event) => {
  console.error('[unhandled rejection]', event.reason);
  event.preventDefault();   // 阻止默认控制台输出,仍需自行上报
});

request('/api/profile').catch((err) => {
  console.log(err.name, err.code, err.context.url);
  // NetworkError NETWORK_ERROR /api/profile
});

错误也要有"可观测性"。上报至少包含:错误名与信息、堆栈、用户动作、页面路径、 版本号与 traceId。用 cause 串起调用链,避免每个 catch 都重新拼一句"请求失败", 把原始堆栈彻底弄丢。

Chapter 05

现代浏览器能力

浏览器早已不只是文档查看器:多线程、全双工通信、强大的正则与调试工具,都是工程能力的一部分。

5.1

Web Worker

精通

Web Worker 在独立线程运行脚本,主线程不会被计算阻塞。Worker 没有 DOM、window、document,但有 self、fetch、IndexedDB、WebSocket 与定时器。它通过 postMessage 通信,数据经过结构化克隆,函数、DOM 节点、原型链都无法传递。

大块二进制数据用 Transferable 转移所有权,避免拷贝:postMessage(data, [buffer]) 之后, 主线程的 ArrayBuffer 长度变为 0。Worker 适合 CPU 密集任务(解析、加密、图像处理、大数据聚合), 不适合频繁的小消息往返,因为序列化与线程调度都有成本。

生命周期要管理:一次性任务完成后调用 terminate;长期 Worker 用消息协议区分任务类型并配对 id; 错误通过 error 事件上报,Worker 内部未捕获的异常不会冒泡到主线程的 try/catch。 模块化 Worker 需设置 { type: 'module' },并用同源路径创建;模块 Worker 里用 import 引入依赖,经典 Worker 则用 importScripts,两者不要混用。

// ---------- 主线程 ----------
const worker = new Worker('./workers/stats.worker.js');

worker.addEventListener('message', (event) => {
  const { sum, cost } = event.data;
  console.log(`总和 ${sum},耗时 ${cost}ms`);
  worker.terminate();   // 一次性任务结束后释放线程
});

worker.addEventListener('error', (event) => {
  console.error('Worker 内部错误:', event.message);
});

worker.postMessage({
  type: 'sum',
  numbers: Array.from({ length: 200000 }, (_, i) => i)
});

// ---------- workers/stats.worker.js ----------
// Worker 中没有 window / document,但有 self、setTimeout、fetch、IndexedDB
self.addEventListener('message', (event) => {
  const start = performance.now();
  const { type, numbers } = event.data;
  if (type !== 'sum' || !Array.isArray(numbers)) return;

  let sum = 0;
  for (let i = 0; i < numbers.length; i++) sum += numbers[i];

  self.postMessage({
    sum,
    cost: (performance.now() - start).toFixed(1)
  });
});

先量再拆。Worker 的创建与消息序列化都有成本,几十毫秒以内的任务放进去可能更慢。 先用 performance 测量主线程耗时,确认确实是 CPU 瓶颈,再考虑搬进 Worker。

5.2

WebSocket 实时通信

进阶

WebSocket 通过一次 HTTP Upgrade 握手建立全双工连接,之后双方可以随时发送文本或二进制帧。 相比轮询,它省去重复握手与头部开销,适合聊天、协作编辑、行情推送。浏览器 API 提供 open / message / error / close 四个事件与 send 方法。

连接可能"假死":网络中断时 TCP 未必立刻报错,close 迟迟不触发。因此需要应用层心跳: 定时发送 ping,服务端回 pong,超过若干周期没有收到任何消息就主动关闭并重连。心跳间隔要与服务端约定, 太短会浪费流量,太长则故障发现慢。

重连要指数退避并加随机抖动,避免服务端重启时所有客户端同时冲击;同时限制最大次数,区分主动关闭与异常断开。 重连成功后需要重新订阅频道、补拉增量数据,这部分幂等逻辑往往比连接本身更复杂。

class RealtimeClient {
  constructor(url) {
    this.url = url;
    this.retry = 0;
    this.closedByUser = false;
    this.timer = null;
    this.connect();
  }
  connect() {
    this.socket = new WebSocket(this.url);

    this.socket.addEventListener('open', () => {
      this.retry = 0;
      this.startHeartbeat();
      this.send({ type: 'subscribe', channel: 'notifications' });
    });

    this.socket.addEventListener('message', (event) => {
      const data = JSON.parse(event.data);
      if (data.type !== 'pong') console.log('收到消息', data);
    });
    this.socket.addEventListener('close', () => {
      this.stopHeartbeat();
      if (this.closedByUser || this.retry >= 5) return;
      // 指数退避 + 抖动,避免同时重连造成雪崩
      const delay = Math.min(30000, 500 * 2 ** this.retry) + Math.random() * 300;
      this.retry++;
      setTimeout(() => this.connect(), delay);
    });
  }
  startHeartbeat() {
    this.timer = setInterval(() => {
      if (this.socket.readyState === WebSocket.OPEN) this.send({ type: 'ping' });
    }, 25000);
  }

  stopHeartbeat() { clearInterval(this.timer); }

  send(payload) {
    if (this.socket.readyState !== WebSocket.OPEN) return false;
    this.socket.send(JSON.stringify(payload));
  }
}

const client = new RealtimeClient('wss://example.com/ws');

不要用 WebSocket 传超大文件。消息没有分片语义,大 payload 会占满内存并阻塞解析。 文件走 HTTP 上传,WebSocket 只传"进度与状态"这类小消息,必要时自行定义分片协议与序号。

5.3

正则进阶

进阶

正则的分组分为捕获组 (...) 与命名捕获组 (?<name>...),后者让 match 结果的 groups 可以按名字取值,替换时也能使用 $<name>。 非捕获组 (?:...) 只分组不占编号,性能略好,也避免打乱 $1 的顺序。

断言只匹配位置,不消耗字符:(?=...)、(?!...) 是先行断言, (?<=...)、(?<!...) 是后行断言。密码强度校验常用多个先行断言叠加。 量词的贪婪(*、+)会尽量多吃,懒惰(*?、+?)尽量少吃, 不匹配时再回溯。

工程上要警惕灾难性回溯:嵌套量词 (a+)+ 在长文本上可能指数级爆炸,即 ReDoS。 避免嵌套量词、限制输入长度、优先使用更精确的字符类。常用校验不要追求"完美邮箱正则", 按业务放宽并配合服务端验证。带 g 标志的正则有 lastIndex 状态, 复用 test 时要留意。

// 命名捕获:比位置下标更可读
const log = '2026-11-16 09:24:31 [ERROR] 支付回调超时';
const logRe = /^(?<date>\d{4}-\d{2}-\d{2}) (?<time>[\d:]{8}) \[(?<level>[A-Z]+)\] (?<msg>.+)$/;
const { groups } = log.match(logRe);
console.log(groups.date, groups.level, groups.msg);

// 断言:只匹配位置,不消耗字符
console.log(/^(?=.*[A-Z])(?=.*\d)[A-Za-z\d]{8,16}$/.test('Sage2026')); // true
console.log(/\d+(?= 元)/.test('共 128 元'));                           // true

// 贪婪 vs 懒惰
const html = '<p>a</p><p>b</p>';
console.log(html.match(/<p>.*<\/p>/)[0]);    // 贪婪:整段
console.log(html.match(/<p>.*?<\/p>/)[0]);   // 懒惰:只到第一个

// 常用校验:手机号、日期格式
const isPhone = (s) => /^1[3-9]\d{9}$/.test(s);
const isDate = (s) => /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/.test(s);
console.log(isPhone('13800138000'), isDate('2026-11-16')); // true true

// 命名分组配合 replace,避免依赖 $1/$2 的顺序
const tpl = '你好,{name}!你的订单 {id} 已发货';
const filled = tpl.replace(/\{(?<key>\w+)\}/g, (match, key) =>
  key === 'name' ? '林知远' : 'A1024'
);
console.log(filled); // "你好,林知远!你的订单 A1024 已发货"

为什么 test 结果忽真忽假。带 g 或 y 的正则会从 lastIndex 继续匹配,同一个正则连续调用会交替命中。要么去掉全局标志,要么每次手动把 lastIndex 归零。

5.4

调试与测试思维

精通

调试的第一步是缩小范围:确认最小可复现路径,逐步二分注释代码,把问题从"页面不对"变成"这个函数在这组输入下 返回了错误的值"。条件断点与日志断点可以避免在循环里反复单步,Watch 面板用来观察关键变量, Call Stack 用来看清调用来源。

console 不只是 log:table 适合数组与对象列表,group / groupEnd 折叠分组, time / timeEnd 计时,trace 打印调用栈,dir 查看对象结构。 debugger 语句等价于断点,但提交前要清理,避免线上用户被意外暂停。

测试思维是调试的延伸:为纯函数写最小断言,先让用例失败(复现),再修到通过(回归保护)。断言要同时给出 期望值与实际值;异步测试要 await 或返回 Promise,否则测试会在结果出来前结束。真实项目可以引入测试框架, 但"最小可复现 + 断言"的思路不变。

// 最小断言库:失败时给出期望值与实际值
function assert(actual, expected, message = '') {
  if (!Object.is(actual, expected)) {
    throw new Error(`${message}\n期望:${String(expected)}\n实际:${String(actual)}`);
  }
  console.log(`通过:${message || '断言'}`);
}

function assertThrows(fn, matcher, message = '') {
  try {
    fn();
  } catch (err) {
    if (matcher && !String(err.message).includes(matcher)) {
      throw new Error(`${message}\n错误信息不匹配:${err.message}`);
    }
    console.log(`通过:${message || '抛错断言'}`);
    return;
  }
  throw new Error(`${message}\n期望抛出异常,但函数正常返回`);
}

// 被测函数:输入非法时立刻失败,而不是返回 NaN
function clamp(n, min = 0, max = 100) {
  if (typeof n !== 'number' || Number.isNaN(n)) {
    throw new TypeError('clamp 只接受数字');
  }
  return Math.min(max, Math.max(min, n));
}

assert(clamp(120), 100, '超过上限被截断');
assert(clamp(-5), 0, '低于下限被截断');
assert(clamp(50), 50, '区间内原样返回');
assertThrows(() => clamp('abc'), '只接受数字', '非数字输入应暴露问题');

// 分组输出,控制台可折叠查看
console.group('clamp 用例');
console.table([
  { 输入: 120, 输出: clamp(120), 期望: 100 },
  { 输入: -5, 输出: clamp(-5), 期望: 0 },
  { 输入: 50, 输出: clamp(50), 期望: 50 }
]);
console.groupEnd();

先写失败用例。能稳定复现的 bug 已经解决了一半。把复现步骤写成一个断言, 修复后它自然变成回归测试,比"我记得改好了"可靠得多。