编程 useState 设同一个值为什么还渲染了一次:eager bailout 要求两份 fiber 都没有 lane

2026-11-23 00:07:43

useState 设置相同的值:为什么有时组件一次都不调用,有时仍会进一次渲染

现象

react.dev 的 useState 文档对这件事的措辞是分两层的:提供的新值与当前 state 相同(由 Object.is 比较确定)时,React 会跳过重新渲染该组件及其子组件;但「在某些情况下 React 仍然需要在跳过子组件之前调用你的组件」,文档同时说明这是优化,不应影响代码逻辑。

把这句话放到实际计数器上,会看到两种截然不同的结果:点「设为相同的 count」,组件函数调用次数有时原地不动,有时多出两次(开发模式 StrictMode 下每次渲染调用两次组件)。差别不在 set 的写法,而在调用发生时 fiber 上挂着什么。

判据:两份 fiber 的 lanes 都为空才走 eager 分支

React 19.3.1 中,useState 返回的 set 走 dispatchSetState → dispatchSetStateInternal(packages/react-reconciler/src/ReactFiberHooks.js,约 3626 / 3656 行)。真正决定「要不要调度渲染」的是 dispatchSetStateInternal 里约 3675–3716 行的这段:

const alternate = fiber.alternate;
if (
  fiber.lanes === NoLanes &&
  (alternate === null || alternate.lanes === NoLanes)
) {
  // The queue is currently empty, which means we can eagerly compute the
  // next state before entering the render phase. If the new state is the
  // same as the current state, we may be able to bail out entirely.
  const lastRenderedReducer = queue.lastRenderedReducer;
  if (lastRenderedReducer !== null) {
    try {
      const currentState = queue.lastRenderedState;
      const eagerState = lastRenderedReducer(currentState, action);
      update.hasEagerState = true;
      update.eagerState = eagerState;
      if (is(eagerState, currentState)) {
        // Fast path. We can bail out without scheduling React to re-render.
        enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update);
        return false;
      }
    } catch (error) {
      // Suppress the error. It will throw again in the render phase.
    }
  }
}
const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);

条件就是 fiber.lanes === NoLanes && (alternate === null || alternate.lanes === NoLanes):当前 fiber 和它的 alternate 都没有待处理的 lane,队列才算「空」,才允许在进入渲染阶段之前先把新 state 算出来。算出来和 queue.lastRenderedState 用 is(即 Object.is)相等,就直接 bailout,连调度都不做——组件函数一次都不会被调用。

只要有一条 lane 挂着,这个分支就不进,set 老老实实入队、调度渲染。渲染到 useState 处再算出相同值,仍然会停在这里,不再往下渲染子组件,但组件函数本身已经被调用过了。

默认值与比较口径:Object.is

useState 的 lastRenderedReducer 是 basicStateReducer(约 1265–1268 行):

function basicStateReducer(state, action) {
  return typeof action === 'function' ? action(state) : action;
}

所以 eager 计算分两种:set(x) 时新值就是 x;set(fn) 时会在这里立刻执行 fn(state)。这也意味着更新函数可能在 set 调用期间就跑一次,渲染阶段再跑一次;如果它抛错,eager 分支里的 try/catch 会吞掉,到渲染阶段再抛出来。

比较口径是 Object.is,与 === 的差别只有两处:

  • NaN 与 NaN 相等(=== 为 false);
  • +0 与 -0 不相等(=== 为 true)。

其余情况下两者结果一致。所以 setCount(NaN) 后再 setCount(NaN) 会被判定为相同值,而 +0 / -0 之间会触发渲染。

互斥与失效点

源码注释写得很直白:eager 是尽力而为的加速,不是保证。以下是几个让捷径失效的具体情况。

同一次 handler 内的第二次 set。 第一次 set 已经把 lane 标记到 fiber.lanes 上,执行到第二次 set 时条件 fiber.lanes === NoLanes 已经不成立,不再尝试 eager,直接入队。这也是为什么批量更新里连续多次 set 不会挨个提前比较。

上一次渲染遗留的 lane。 如果上一次更新还没走完,fiber 上仍带着 lane,同样进不了 eager 分支。要等两份 fiber 都干净,捷径才重新生效。

useReducer 的 dispatch 没有 eager 分支。 dispatchReducerAction 里没有这段提前计算,永远走渲染路径,相同值最多只能在渲染阶段被 is 拦下。

把这些拼起来看实测(19.3.1,开发模式 + StrictMode):

操作组件调用次数effect 次数
首次挂载22
点「设为相同的 count」不变不变
点「+1」43
紧接着点「设为相同的 count」6仍 3
再点一次相同值不变不变

第三行之后那次「设为相同值」,旧 fiber 还带着 lane,eager 捷径被跳过,进了渲染,在 useState 处算出相同值后停住——没有重渲染子组件,也没重跑 effect。再点一次,两份 fiber 都干净,捷径恢复,组件调用次数不再增长。

原地修改数组/对象永不出新值

经典的原地改数组:

items.push("Mint tea");
setItems(items);
// 页面还是 1 items

setItems 收到的是同一个数组引用。eager 分支里 Object.is(items, items) 为 true,直接 bailout,不渲染;即使因为 fiber 带 lane 走了渲染路径,updateReducerImpl 里同样用 is 比较新旧 state,也会在子组件渲染之前停住。两条路都指向同一个结果:引用没变就没有新值。

改成构造新引用才有更新:

setItems([...items, "Mint tea"]);

对应的文档说明在 state 作为快照 和 排队更新 state:队列里的「值」是替换,会忽略前面算出的结果;「函数」参与顺序计算,setNumber(n => n + 1) 才是在前一个结果上累加。

所以「设置相同值很便宜」成立,但「设置相同值一定不渲染」不成立。写更新函数时要当它会被调用不止一次——eager 阶段一次、渲染阶段一次,或者两次都调;保持纯函数,才能让这两种路径给出同一个结果。

复制全文 生成海报 useState React Hooks 前端 源码分析

推荐文章

程序员茄子在线接单