搜索框显示旧词:接口都成功了,错的是顺序
11 月 13 日刷到一条帖子:用户打「保温杯」,下拉里却是「保温」的结果;再补一个字,结果又跳回去。发帖人说,每次请求都成功了。
这句话让我停了一下。没有报错,接口全绿,页面显示的东西是错的——我的判断是:接口都成功了,问题不在接口本身,是旧请求后回来,把新结果盖了。防抖救不了这种顺序问题,真正兜底的是请求编号。
我想验证的也是这件事:防抖、取消、序号叠在一起,到底哪一层真正决定用户看到什么。这篇按方法复盘写,不复述别人的线上数据,只把能复现的部分拆开。
三层各管什么
防抖不解决竞态。 它管的是「多久没输入才发请求」,管不了「谁先回来」。
abort 也只是尽力取消。 请求可能已经在服务端跑完,取消只保证浏览器不再使用这个响应,不保证它没发生过。
真正兜底的是请求编号。 响应回来时对一下「你还是不是最新那一次」,不是就不许写 DOM。
第一层省资源,第二层管正确,第三层管体验:少了第二层只能赌取消每次都成功;少了第一层会白跑请求;少了第三层只是手感差一点。下面按我排查时会走的顺序写。
把现象缩成一条时间轴
假设用户先打「保温」,80 毫秒后打「保温杯」。两次输入各发一条请求:
t=0ms 输入「保温」 → 请求 A(120ms 后返回)
t=80ms 输入「保温杯」 → 请求 B(20ms 后返回)
t=100ms 请求 B 先回,渲染「保温杯」
t=120ms 请求 A 后回,把「保温杯」覆盖成「保温」
请求 A 发出得早,回来得晚;请求 B 发出得晚,回来得早。渲染函数谁回来都能跑,于是晚到的 A 把 B 的结果盖了。
这里没有任何一个环节「失败」。请求成功、JSON 合法、render 也没抛错。唯一错的是:A 不该在 B 之后写 DOM。前端代码里每个函数单看都对,时间线上就是不对——这也是它难查的原因。
最小复现:不打开浏览器也能看见
我把浏览器放到一边,先用 Node 把返回顺序单独跑了一遍(Node 20.19.0)。代码只保留两次请求和一次写 DOM:
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
async function run(guard) {
let seq = 0;
const dom = [];
const api = async (q, delay) => {
await sleep(delay);
return 'result:' + q;
};
const search = async (q, delay) => {
const my = ++seq;
const data = await api(q, delay);
if (guard && my !== seq) {
dom.push('drop ' + q);
return;
}
dom.push('render ' + data);
};
await Promise.all([search('保温', 80), search('保温杯', 20)]);
console.log((guard ? 'guard ' : 'no guard') + ' => ' + dom.join(' | '));
}
await run(false);
await run(true);
跑出来是这样:
no guard => render result:保温杯 | render result:保温
guard => render result:保温杯 | drop 保温
no guard 那行就是线上现象:旧请求末尾渲染,把新结果盖掉。guard 那行里,旧请求回来时发现自己不是最新,直接丢弃。
这段只验证时序逻辑,不代表浏览器或真机行为,别拿它当兼容性结论。
防抖为什么挡不住
最常见的补丁是 300 毫秒防抖。它有用,但作用域比很多人以为的小:它控制「多久没输入才发请求」,不控制「已经发出去的请求谁先回来」。
用户停顿 300 毫秒,再连着打两个字,两次请求依然会并发。中文输入法下更容易漏:连打「保温杯」,三个字可能在两百毫秒内完成,第一次请求已经上路。回车、点筛选、清空重输,也都能绕过防抖。
防抖把并发从常态降成偶发。可竞态只要发生一次,用户就看到错词。
还有一种更隐蔽的:组件复用时,旧请求的回调闭包还挂着上一次的 render。你在代码里看每个函数都对,时间线上就是不对。
第一层:能取消的先取消
AbortController 是现成的第一道闸。每次输入前,把上一笔还没回来的请求取消:
function createSuggest() {
let controller = null;
async function fetchSuggest(q) {
if (controller) controller.abort();
controller = new AbortController();
const res = await fetch('/api/autocomplete', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ q }),
signal: controller.signal,
});
if (!res.ok) throw new Error('autocomplete ' + res.status);
return res.json();
}
return async function search(q) {
try {
const list = await fetchSuggest(q);
render(list);
} catch (e) {
if (e.name === 'AbortError') return;
report(e);
}
};
}
两个使用细节,外加一个前提。
一是 AbortError 不要当异常上报。主动取消是正常路径,扔进全局监控,线上会多出一堆假错误。
二是取消是「尽力而为」。请求可能已经到服务端,服务端照常处理、照常记日志;abort() 省的是浏览器侧的等待和部分流量,不是「这次请求没发生过」。
这段只覆盖「请求还在路上」。如果响应已经到手、代码正要 render,abort() 拦不住,还是得靠下一层。
还有一个前提:老内核不一定有 AbortController。上线前先探测 typeof AbortController === 'function',没有就只靠下一层,别硬写。
第二层:序号守卫,决定谁能写 DOM
这层才是正确性的底线。思路很土:每次搜索前自增一个序号,响应回来时对一下,不是最新就丢弃。
// 每个搜索框实例一份,不要放在模块顶层
let seq = 0;
async function search(q, filters) {
const mySeq = ++seq;
const res = await fetch('/api/search', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ q, ...filters }),
});
if (!res.ok) throw new Error('search ' + res.status);
const data = await res.json();
if (mySeq !== seq) return;
renderResults(data);
}
关键在 mySeq 是发请求前就定下来的,不能等响应回来再比。否则两个响应同时到达,谁先执行谁就拿到同一个「当前值」,等于没比。
作用域也要卡死:序号是「一个搜索框一份」。放到模块顶层,页面里两个搜索框会互相判负;React 里用 useRef,Vue 里放到组件实例的闭包里。路由切走或组件卸载时把序号加一,晚到的响应自然作废。
为什么不直接比较关键词?同一个词可能被重试,不同筛选条件也可能用同一个词。序号单调递增,比较便宜,也不会误判。
也别拿服务端返回的时间戳排序。客户端和服务端的钟不一定对得上,跨机器还可能差几秒;序号在客户端生成,只回答「谁是最新一次」,不依赖任何时钟。
abort 和序号不是重复劳动:前者省资源,后者保正确。只做 abort,遇到「取消失败」或「响应已经在路上」的时序,旧结果照样能写进来;只做序号,旧请求会白跑,流量和并发都浪费。
第三层:缓存和先渲染
竞态修完,体验还能再进一步。用户从「保温」打到「保温杯」,两次结果高度重合,可以把上一次的列表先渲染,新结果回来再替换:
const cache = new Map();
async function searchWithCache(q, filters) {
const mySeq = ++seq;
const key = q + '|' + JSON.stringify(filters);
if (cache.has(key)) {
renderResults(cache.get(key));
return;
}
const data = await request(q, filters);
cache.set(key, data);
if (mySeq !== seq) return;
renderResults(data);
}
缓存 key 要带全部影响结果的参数,不能只用 q。筛选条件一变,旧列表就不能复用,否则你会修好竞态,又造出一个「筛选没生效」。
request 是项目里的请求封装,这里只关心它返回 Promise;seq 沿用上一段的实例变量。
缓存只放页面生命周期,别写 localStorage:用户换个词,旧结果就没用了,还可能把过期数据带回来。给 Map 一个上限,别让它无限涨。
缓存命中时是同步渲染,不存在乱序。但如果把缓存读取做成异步(比如 IndexedDB),它同样要过序号校验——判断标准不是「代码在哪一层」,而是「写 DOM 之前有没有 await」。
旧请求还会改掉 loading 和错误提示
竞态不只影响列表内容,请求的「副作用」也会乱序:旧请求的 finally 把 loading 关掉,新请求还在飞,转圈提前消失;旧请求超时后弹一个错误提示,盖在新结果上。用户看到的是「搜索坏了」,你去查接口,接口又都正常。
async function search(q) {
const mySeq = ++seq;
setLoading(true);
try {
const data = await request(q);
if (mySeq !== seq) return;
renderResults(data);
} catch (e) {
if (mySeq !== seq) return;
if (e.name === 'AbortError') return;
showError(e);
} finally {
if (mySeq === seq) setLoading(false);
}
}
判断标准只有一条:这次响应、这次异常、这次收尾,还是不是当前这次搜索。不是,就什么状态都别改。setLoading、showError、request 都是占位,按项目替换。
中文输入法:另一个制造并发的入口
拼音输入时,input 事件会在组合期反复触发,值还是半成品。每次触发都发请求,等于人为把并发拉高。
处理不复杂:组合期不打请求,组合结束再统一走一次调度。
let composing = false;
input.addEventListener('compositionstart', () => {
composing = true;
});
input.addEventListener('compositionend', () => {
composing = false;
schedule(input.value);
});
input.addEventListener('input', (e) => {
if (composing || e.isComposing) return;
schedule(e.target.value);
});
e.isComposing 和 composing 两个都判,是因为不同输入法、不同浏览器的事件顺序不完全一样,单靠一个标志容易漏。schedule 就是前面的防抖入口,这里不展开。
这不是竞态本身,但它会凭空制造更多并发请求,把上面的问题放大。搜索框接中文输入法,这一段迟早要补。
一张判断树
线上再遇到「搜索建议不对」,我按这个顺序问,不先改代码:
flowchart TD
A[用户说下拉结果不对] --> B{同一次输入发了几条请求}
B -- 只有一条 --> C[查接口数据与缓存 key]
B -- 多条 --> D{写 DOM 的是不是最新一次请求}
D -- 是 --> E[结果本身不对 查服务端排序]
D -- 否 --> F[请求竞态]
F --> G{有 AbortController 吗}
G -- 没有 --> H[先取消上一笔]
G -- 有 --> I{响应回来有 seq 校验吗}
I -- 没有 --> J[加请求序号 旧响应丢弃]
I -- 有 --> K[查 seq 作用域是否被多实例共享]
判断树的价值不在于覆盖所有情况,而在于每一步都能拿到证据:Network 面板里的请求条数、最终 DOM 里的词、控制台有没有 AbortError。没有证据,就别急着改渲染。
上线前我会跑的检查
| 检查项 | 怎么操作 | 通过标准 |
|---|---|---|
| 请求条数 | Network 面板过滤接口,快速输入两个词 | 旧请求显示 canceled,或被序号丢弃 |
| 最终内容 | 让先发的那次请求比后发的晚回 | 页面显示最新一次输入的结果 |
| 取消异常 | 看控制台和错误上报 | 没有 AbortError 被当异常上报 |
| 组件卸载 | 发请求后立刻切路由 | 不再写 DOM,不报卸载后更新 |
| 多实例 | 页面放两个搜索框交替输入 | 互不取消、互不覆盖 |
| 缓存 key | 改筛选条件后搜同一个词 | 不出现上一次筛选的结果 |
| 输入法 | 用拼音连续输入一个词 | 组合期不发请求 |
「让先发的请求晚回」是测试手段,不是性能指标。它的作用是人工制造乱序,让问题从「偶发」变成「必现」。
这套东西不解决什么
服务端返回的数据本身就是错的,竞态修不了,得回去查排序和召回。
分页搜索要额外小心:第二页的请求回来得早,会被第一页的序号判掉。序号要跟「查询条件 + 页码」走,或者每页单独维护。
多标签页各自独立,不需要跨页序号;但同一页面里的多个搜索框不能共享一个序号。
缓存会带来陈旧数据。价格、库存、余额这类结果别照搬这套,宁可多请求一次。
事实边界
- 触发案例来自 2026-11-13 的技术社区公开帖《搜索框显示错词:用 SerpBase 修请求竞态与取消》(juejin.cn/post/770731…
- 本机验证:2026-11-14 用 Node 20.19.0 跑了上面的时序模拟,输出与文中一致。它只验证「旧响应会覆盖新结果」这一逻辑,不是浏览器或真机实测。
- 规范依据:Fetch 标准中 abort 与
AbortError的定义(fetch.spec.whatwg.org/#abort-fetc… MDN 的 AbortController 条目(developer.mozilla.org/docs/Web/AP… - 未验证:各浏览器与老内核对
AbortController的支持情况、不同输入法的 composition 事件顺序。文中只给检测方法,不给版本结论。 - 全文没有性能数字;300 毫秒是示例参数,不是测量结果。