搜索框显示旧词:接口都成功了,错的是顺序

1 阅读11分钟

搜索框显示旧词:接口都成功了,错的是顺序

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 毫秒是示例参数,不是测量结果。