先看一个很多人都被坑过的场景:点击按钮后先显示「加载中」,再跑一段要两秒的同步计算,最后把加载提示藏掉。代码看起来没问题,可用户从头到尾没看到那个转圈,点完直接卡住两秒,然后结果出来。还有人写过这种判断:先发请求,立刻读结果,发现永远是空的。这些都不是手速问题,而是 JS 的执行模型决定的。

这篇讲的就是「代码到底按什么顺序跑」:调用栈管同步代码,队列管异步回调,事件循环负责在两者之间来回搬。读完你能做到:看到一段混杂着 setTimeout、Promise、async/await 的代码,能自己推出输出顺序;遇到「界面没刷新」「请求还没回来就被用了」这类问题,知道该往哪查。文中每个例子都能直接贴到控制台跑,结果不是猜的。

先看一个真实的翻车现场

下面这段代码,很多人第一次写都会觉得输出是 A B C D 或者 A D B C,实际是 A D C B。

console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
console.log('D');
// 实际输出:A D C B

为什么 C 排在一个延迟 0 毫秒的定时器前面?因为「延迟 0 毫秒」不等于「马上执行」,它只是「尽快排进某个队列」;而 Promise 的回调进的是另一个优先级更高的队列。要理解这个差别,得先认识两个东西:调用栈和任务队列。

调用栈:JS 一次只能干一件事

JS 在浏览器的主线程上是单线程执行的,同一时刻只跑一段代码。这段代码的执行位置用「调用栈」记录:你调用一个函数,就往栈顶压一层;函数返回,就弹出一层。栈空了,这一轮同步代码就结束了。

单线程的好处是不用处理多线程并发改同一个变量的问题,坏处是一段代码卡住,后面所有事都得等。一个两秒的 for 循环跑在主线程上,这两秒里页面不能更新、按钮不能响应、动画全部停住。所以「页面卡了」很多时候不是渲染慢,而是主线程被一段同步代码占住了。

任务队列:主线程空下来才轮到它们

异步操作的 callback 不会插队到当前代码中间执行,而是先被放进队列排队。主线程把当前这轮同步代码跑完、调用栈清空之后,事件循环才从队列里取下一个任务来执行。队列不止一个,优先级也不一样,日常需要分清的是两种:

宏任务(macrotask)

可以粗略理解成「一件独立的事」:一次定时器回调、一次用户点击的事件处理、一个网络请求完成后的回调、一次整体脚本执行。宏任务队列每轮只取一个来跑,跑完再看有没有微任务。

微任务(microtask)

可以理解成「当前这件事的收尾工作」:Promise 的 then/catch/finally 回调、queueMicrotask 排进去的函数、MutationObserver 的回调。每执行完一个宏任务,事件循环会把微任务队列整个清空,清空之后才继续下一个宏任务。而且清空过程中新产生的微任务也会被一起跑掉,所以微任务有可能「没完没了」。

这里说的是浏览器环境。Node.js 的事件循环分更多阶段,顺序不完全一样,别把浏览器结论直接搬到 Node 上。

一轮事件循环,到底按什么顺序

把一轮简化成四步,足够应付日常判断:

一轮事件循环的顺序
取一个宏任务执行
清空微任务队列
必要时渲染
进入下一轮

关键点有三个:第一,微任务不是「插在同步代码中间」,而是等当前宏任务彻底跑完才处理;第二,微任务队列要清空,不是只跑一个;第三,渲染不是每轮都发生,浏览器会按屏幕刷新节奏来决定要不要画,一般不会在你刚改完样式就立刻画。

用这个模型回看开头那段代码:整体脚本算一个宏任务,同步的 A、D 先输出;脚本结束后清空微任务,C 输出;这一轮结束,下一轮才轮到定时器,B 输出。顺序就是 A D C B。

setTimeout 为什么不精确

setTimeout(fn, 0) 的真实含义是「至少等 0 毫秒,并且要等前面排队的任务都跑完,才可能执行」。它不保证准时,只保证「不会早于这个时间」。原因很实在:

  • 定时器到点只是把回调放进宏任务队列,前面还有别的任务在排队,它就得等。
  • 如果当前有一个长任务在跑,比如一个很大的循环,定时器只能等它跑完。
  • 规范对嵌套定时器有最小延迟限制,嵌套层数多了之后,0 毫秒实际上会被抬到几毫秒;后台标签页还可能被整体降频到更长的间隔。具体阈值各浏览器实现有差异,属于待确认细节,但「不精确」这件事是确定的。

所以拿 setTimeout 做精确动画、精确计时、精确调度,方向就错了。动画要用 requestAnimationFrame,它跟屏幕刷新对齐;需要稳定时间间隔的场景,应该基于真实时间差来补偿,而不是假设每次回调都间隔 16 毫秒。

Promise 和 async/await 的真实顺序

这是最容易翻车的一块。记住一条:await 后面的代码,等价于放进微任务里稍后执行,而不是原地继续。

先看一个混着 async 的版本,实际输出是 start、async start、sync end、promise、async end、timeout:

console.log('start');
setTimeout(() => console.log('timeout'), 0);
Promise.resolve().then(() => console.log('promise'));

(async () => {
  console.log('async start'); // await 之前是同步执行的
  await null;
  console.log('async end');   // await 之后进了微任务
})();

console.log('sync end');
// 输出:start, async start, sync end, promise, async end, timeout

解释一下:async 函数被调用后会立刻同步执行到第一个 await,所以 async start 排在外层 sync end 前面;await 把后半段挂起,等同步代码跑完,微任务队列里依次是 promise 和 async end;最后才是定时器。

再看一个嵌套 await 的例子,输出是 0 1 3 4 2 5:

async function a() {
  console.log(1);
  await b();
  console.log(2);
}
async function b() {
  console.log(3);
  await null;
  console.log(4);
}

console.log(0);
a().then(() => console.log(5));
// 输出:0 1 3 4 2 5

流程是:0 先输出;调用 a 后同步输出 1,进入 b 输出 3,b 在 await null 处挂起;此时栈空,开始跑微任务,b 恢复输出 4;b 返回后,a 的 await 才恢复,输出 2;a 完成后,它的 then 回调输出 5。

一个常见误区是认为「await 会让出线程,所以后面的代码会等下一个宏任务」。不是。它让出的是当前函数的执行,恢复时走的是微任务,优先级比定时器高。你在 await 后面写 setTimeout,两者顺序会和你直觉相反。

渲染在什么时候插进来

浏览器渲染不是随时发生的,它通常安排在一轮任务和微任务处理完之后、下一轮任务之前,并且会尽量贴合屏幕刷新节奏。这个细节直接导致一类经典 bug:

button.addEventListener('click', () => {
  loading.hidden = false; // 想让用户看到转圈

  const start = Date.now();
  while (Date.now() - start < 2000) {
    // 模拟两秒的同步计算
  }

  loading.hidden = true;  // 立刻又藏起来
});

这段代码里,点击处理是一个宏任务。改 hidden 只是改了 DOM,浏览器不会在任务中途停下来重绘;两秒的循环把主线程占死,期间根本没有渲染机会;等任务结束,两个改动一起生效,用户只看到「卡了两秒,然后什么都没有」。这不是 CSS 写错了,是执行顺序不给你展示的机会。

要修,不能靠「加个 setTimeout 包一层」就完事。真正要做的是把长计算让出去:拆成小段、每段之间让事件循环跑一轮,或者干脆扔进 Web Worker。只是把提示显示出来再计算,await new Promise((resolve) => setTimeout(resolve, 0)) 这类让出方式通常能让浏览器有机会画一帧,但它不是精确保证,别拿它当渲染同步的开关。

实际项目里的用法与取舍

理解了顺序,落到业务里常见两种用法:

  • 防抖:输入框搜索建议、窗口 resize,通常等用户停下来再发请求。代价是「最后一下」的反馈会延迟,用户敲得快时可能觉得没反应;搜索这种场景可以配合「先显示本地结果、再补远程结果」,别让用户盯着空白等。
  • 节流:滚动加载、拖拽跟随,固定时间间隔最多执行一次。代价是快速滚动时内容更新会滞后,体验上要接受一点「追不上」的感觉。
// 一个够用的防抖:停止输入 300 毫秒后才真正查询
function debounce(fn, wait) {
  let timer = null;
  return function (...args) {
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(this, args), wait);
  };
}

const search = debounce((keyword) => {
  fetch('/api/search?q=' + encodeURIComponent(keyword));
}, 300);

这类工具函数网上很多,但你要知道它依赖的就是「定时器进宏任务、可以被取消」这个机制。clearTimeout 能取消,是因为回调还没被取出来执行。

排查顺序问题的几条经验

遇到「顺序不对」时,别急着改代码,先定位这段代码在哪个任务里:

  • 在关键位置打时间戳,用 performance.now() 而不是 Date.now(),前者精度更高。日志顺序比脑补可靠。
  • 看到 async 函数,先把 await 之前的部分当同步代码看,这样能解释大半「为什么它先执行」。
  • 如果某段逻辑依赖「DOM 已经更新」,直接用 nextTick 之类的猜测不可靠;用 requestAnimationFrame 或 MutationObserver 更明确。
  • 页面「卡住不刷新」时,先找同步长任务,而不是怀疑 CSS 或框架。打开性能面板看到一长条黄色/红色的任务块,基本就锁定了。
  • 不要用 setTimeout(fn, 0) 去「保证顺序」,它只保证比当前同步代码晚,不保证比别的回调早。

走一遍真实排查:进度条从头到尾没动过

一个后台的「批量导入」功能:用户选一个表格文件,点开始,页面要把几千行数据渲染成预览表格。产品要求中间显示进度条。上线后收到的反馈是「进度条坏了,一直 0%,最后直接跳到完成」。

第一次判断。进度条是个现成组件,怀疑它没响应数据变化。换了个写法,把手动改宽度换成组件自带的 value 属性,现象没变。又怀疑是 CSS 过渡没生效,去掉了过渡,还是不动。到这一步可以排除「组件和样式」。

第二次判断,方向偏了。接着怀疑接口慢,因为「进度条不动」听起来像「没收到进度」。看 Network,请求确实花了两秒才返回,但返回之后页面还有一段明显的卡顿,然后表格一次性出现、进度条直接满格。也就是说,进度条的问题发生在数据回来之后,不是请求期间。

开始量。用 Performance 录一次点击,看到一条接近两秒的长任务,整段都在 JS 执行和 DOM 操作上,中间没有任何渲染帧。代码结构很简单:请求回来后一个 for 循环,每行拼一段 HTML 塞进表格,循环里顺手把进度条的宽度改一下。

原因。点击回调本身是一个宏任务。循环在这一个任务里从头跑到尾,中间改了多少次进度条都只是改了 DOM 的属性,浏览器没有机会画;等循环结束、任务退出,最后一次赋值生效,用户看到的就是「一直 0%,然后满格」。这不是组件问题,是执行顺序不给渲染留缝隙。

第一次修,没修好。在循环外面包了一层 setTimeout(fn, 0),想让渲染先发生。没用,因为被包住的仍然是那一整段同步循环,只是整体往后挪了一个任务,中间依然没有空隙。这个误区很常见:让出必须发生在「长任务内部」,包在外面等于没让。

第二次修,有效但有代价。把循环改成分片,每处理 200 行让出一轮:

async function renderRows(rows, tbody, progress) {
  for (let i = 0; i < rows.length; i += 200) {
    const slice = rows.slice(i, i + 200);
    tbody.append(buildFragment(slice));   // 一批插入

    const done = Math.min(i + slice.length, rows.length);
    progress.style.width = (done / rows.length * 100) + '%';

    // 让出一轮宏任务,浏览器才有机会把上面的改动画出来
    await new Promise((resolve) => setTimeout(resolve, 0));
  }
}

改完之后进度条开始动了,但总耗时比原来多了一点。原因是这种让出不是免费的,后面讲边界时会展开。后来把每片从 200 行调到 500 行,进度更新次数少了,视觉上仍然够用,总耗时也回来了。

这个案例的关键判断是「长任务内部有没有空隙」。只要一段同步代码从头跑到尾,你在里面改多少次 DOM 都不会被画出来;反过来说,只要在中间真的让出过,哪怕只让一轮,浏览器就有机会更新画面。

现象对照:顺序问题的常见长相

你看到的现象更可能的原因第一步查什么
加载提示从头到尾没出现,结束后直接跳到结果显示提示和长计算在同一个任务里,中间没有让出,浏览器没有渲染机会用 Performance 录一次,看这两步之间有没有帧;有长任务就先拆任务
forEach 里写了 await,后面的代码却没等它forEach 不关心回调返回的 Promise,它同步调用完所有回调就结束了换成 for...of 或在 Promise.all 里收集,再确认执行顺序
两个请求都发了,先发的后回来,页面显示错乱网络返回顺序本来就不保证,代码却假设「先发先到」给请求编号或带上当前关键词,回来时比对,不匹配就丢弃
定时器设了 100 毫秒,实测经常一百多到点只是入队,前面还有任务在跑;嵌套定时器还有最小延迟限制记录实际间隔,确认是不是被长任务顶住;需要精确节奏就换 requestAnimationFrame
页面在后台放久了,回来时定时器像是一起补跑了后台标签页的定时器会被降频,恢复时排队的回调集中执行用时间戳判断「真实过了多久」,不要靠回调次数累加
一段 Promise 递归写错,页面直接失去响应微任务队列被无限填充,事件循环一直清微任务,永远轮不到渲染和下一个宏任务看是不是在 then 里无条件再排一个微任务;加退出条件和计数

这些现象有一个共同点:代码在「你以为的时机」之外执行。所以排查时不要先读业务逻辑,先确认这段代码属于哪个任务、它前面排了谁。

这套模型的边界与代价

  • 它描述的是浏览器,不是所有 JS 环境。Node.js 有自己的阶段划分,比如定时器、IO 回调、setImmediate 的先后关系跟浏览器不一样。把这里的结论直接搬去写服务端代码,会得到相反的结果。
  • 让出是有成本的。每次让出一轮,至少要等一个任务周期;连续用 setTimeout 让出,嵌套到一定层数后每轮会被抬到最少 4 毫秒左右(规范里的最小延迟限制)。分 100 片就多花几百毫秒,这时候要么加大每片的量,要么改用 requestAnimationFrame 按帧让出。
  • 让出会打乱「一次做完」的前提。分片之后,每一片之间用户可能点击、切换页面、甚至删除正在处理的数据。你得考虑中途状态变化,必要时用标记位取消后续分片。原来那段「一口气跑完」的代码反而没有这个问题。
  • 微任务不是越多越好。微任务会在一个宏任务后全部清空,清空期间新产生的微任务也会继续跑。写成一个自我循环的微任务链,界面会完全失去响应,连定时器都没机会执行。
  • requestAnimationFrame 也不是随时都跑。页面在后台、或者标签页被最小化时,它会被暂停或降频。拿它做计时同样不可靠,它适合的是「下一帧要画的东西」。

还有一个容易被忽略的代价:把重活挪进 Web Worker 确实能让主线程空出来,但 worker 和主线程之间传数据要复制或转移,数据量大时这部分开销很可观,而且 worker 里碰不到 DOM,渲染还是得回主线程做。它是解法之一,不是免费的银弹。

当天就能做的四件事

  1. 写一个按钮,点击后先显示「处理中」,再用一个 while 循环空转两秒,最后隐藏提示。你会复现「提示从来没出现」。然后在循环中间插入一次 await new Promise(r => setTimeout(r, 0)),观察区别。
  2. 用 for 循环往页面里插入 3000 个列表项,循环内每 100 项改一次进度文字,不做任何让出,然后用 Performance 看这一段有几帧。
  3. 写一个 forEach 加 await 的例子,打印每个元素的处理顺序,再改成 for...of 对比。两次输出会让你记住这个坑。
  4. 用 performance.now() 记录连续 20 次 setTimeout(fn, 0) 的实际间隔,把结果打出来。你会看到前几次接近 0,后面被抬到几毫秒。

小结与下一篇

压缩成几句话:同步代码在调用栈上跑,一次只跑一个;跑完先清空微任务(Promise 回调、await 后半段),再去取下一个宏任务(定时器、事件回调);渲染插在任务之间,不保证每次任务后都发生。因此 setTimeout 不精确,await 后面的代码比定时器先跑,长任务会让界面停止更新。

下一篇建议读DOM 与 BOM,看看代码具体怎么操作页面和浏览器;如果你现在更关心卡顿,可以跳到页面为什么会卡。想回头补渲染那一段,读浏览器渲染管线。