Mini-React实现
- 1Mini-React实现本文
- 2Vue响应式原理
- 3前端模块化
- 4地址栏输入URL敲下回车发生了什么?
- 5浏览器性能与优化
- 6计算机网络笔记
手写一个迷你 React:从 JSX 到 Hooks,吃透 Fiber 与并发渲染
本文基于 Rodrigo Pombo 的经典教程 Build your own React 的实践笔记整理。我们用约 300 行代码实现了一个名为 Didact 的迷你 React,覆盖 React 最核心的机制:JSX、虚拟 DOM、Fiber 架构、时间切片、双缓冲、Reconciliation、函数组件与 Hooks。
完整代码见文末,本文对应文章 Step 0 ~ Step VIII 的全部内容。
0. 为什么值得手写一遍 React
日常开发中我们熟练地使用 useState、useEffect,但很少追问:
setState之后到底发生了什么?- 为什么大列表渲染时 React 不会卡死浏览器?
- 为什么 Hooks 不能写在
if里?
这些问题的答案都藏在 React 的渲染管线里。跟着文章把这条管线亲手实现一遍之后,面试中 80% 的 React 原理题都会变成”我写过这个”。
先看一下 Didact 的最终形态——一个可点击的计数器,语法和 React 完全一致:
/** @jsx Didact.createElement */function Counter() { const [state, setState] = Didact.useState(1) return <h1 onClick={() => setState(c => c + 1)}>Count: {state}</h1>}const element = <Counter />const container = document.getElementById('root')Didact.render(element, container)1. 全景:一次渲染的三个阶段
在深入每一步之前,先建立整体认知。Didact(也是 React)的一次更新分为三个阶段:
| 阶段 | 干什么 | 能否中断 |
|---|---|---|
| Render(渲染) | JSX → element 树 → fiber 树,计算出新旧树的差异 | ✅ 可中断(时间切片) |
| Commit(提交) | 把差异一次性应用到真实 DOM | ❌ 必须同步完成 |
| Browser Paint | 浏览器绘制 | —— 不归我们管 |
支撑这三个阶段的核心数据结构是 element 和 fiber:
JSX ──babel──▶ createElement() ──▶ element 树(虚拟 DOM,纯描述) │ ▼ reconcile fiber 树(工作单元,可遍历可中断) │ ▼ commit 真实 DOM2. Step I:createElement —— JSX 只是语法糖
JSX 会被 Babel 编译为函数调用。文件顶部的注释 /** @jsx Didact.createElement */ 告诉 Babel:把 JSX 编译成 Didact.createElement(...) 而不是 React.createElement(...)。
所以 JSX 编译后的产物不是 DOM,而是普通的 JS 对象:
function createElement(type, props, ...children) { return { type, props: { ...props, children: children.map(c => typeof c === 'object' ? c : createTextElement(c) ) } }}
function createTextElement(text) { return { type: 'TEXT_ELEMENT', props: {nodeValue: text, children: []} }}两个设计细节:
- element 只有两个字段:
type(标签名或组件函数)和props(含children)。children是数组,天然支持任意嵌套。 - 文本节点统一包成
TEXT_ELEMENT:JSX 中字符串/数字 child 不是对象,为了后续 diff 时结构统一,全部包装成{ type: 'TEXT_ELEMENT', props: { nodeValue } }。这样 reconcile 时只需要比较type是否相同,不需要对文本做特殊分支。
3. Step II:render —— 从对象到真实 DOM
最朴素的 render 是递归:根据 element.type 创建 DOM 节点,赋值属性,然后递归 append 所有 children。这一步没有难点,但它有一个致命缺陷——递归一旦开始就无法停止。一棵几千个节点的树会长时间霸占主线程,动画和输入全部掉帧。
这就是 React 16 重写架构的动机,也是后面所有设计的出发点。
4. Step III:并发模式 —— 让渲染可中断
解决方案:把渲染工作拆成一个个小单元,利用浏览器空闲时间分批执行,而不是一口气跑完。
function workLoop(deadline) { let shouldYield = false while (nextUnitOfWork && !shouldYield) { nextUnitOfWork = performUnitOfWork(nextUnitOfWork) shouldYield = deadline.timeRemaining() < 1 // 本帧剩余时间不足 1ms,让出主线程 }
if (!nextUnitOfWork && wipRoot) { commitRoot() // 所有工作单元完成 → 进入提交阶段 }
requestIdleCallback(workLoop) // 注册下一次空闲回调}requestIdleCallback(workLoop)requestIdleCallback 是浏览器提供的 API:主线程空闲时调用回调,并通过 deadline.timeRemaining() 告知本帧还剩多少时间。每一帧只做”来得及做完”的几个工作单元,做完就让路——这就是时间切片(Time Slicing)。
注:真实 React 并没有用
requestIdleCallback(它触发频率太低、时机不可控、缺乏优先级),而是自己实现了 Scheduler(基于MessageChannel)。但核心思想完全一致。
5. Step IV:Fiber —— 既是数据结构,也是工作单元
可中断的前提是:渲染过程必须能”暂停后继续”。递归调用栈是做不到这点的,因为栈帧一旦弹出,中间状态就丢了。所以 React 把”树”改造成了”链表”,每个节点就是一个 fiber。
Didact 中 fiber 的结构:
{ type, // 标签名或组件函数 props, // 属性(含 children) dom, // 对应的真实 DOM 节点 parent, // 父 fiber child, // 第一个子 fiber sibling, // 下一个兄弟 fiber alternate, // 指向旧树中对应的 fiber(双缓冲,见第 7 节) effectTag, // 本节点要执行的 DOM 操作类型}parent / child / sibling 三个指针把树变成了可以用循环(而非递归)遍历的结构。performUnitOfWork 的深度优先遍历顺序是:有孩子先走孩子 → 没孩子走兄弟 → 兄弟也没有就向上找”叔叔”:
function performUnitOfWork(fiber) { // ...构建当前 fiber 的子 fiber(reconcile)
if (fiber.child) return fiber.child // 1. 优先深入子节点 let nextFiber = fiber while (nextFiber) { if (nextFiber.sibling) return nextFiber.sibling // 2. 其次兄弟 nextFiber = nextFiber.parent // 3. 最后回溯到父级的兄弟 }}因为每一步的”下一步去哪”都可以从 fiber 自身的指针算出来,所以遍历可以在任意一个 fiber 上暂停,下次空闲时从 nextUnitOfWork 原样继续——这就是可中断渲染的本质:把隐式的调用栈显式化为数据。
6. Step V:Render 与 Commit —— 双缓冲与 alternate
可中断带来一个新问题:如果渲染到一半就把结果写到真实 DOM 上,用户会看到”半新半旧”的撕裂界面。所以必须把计算差异和应用差异拆成两个阶段,同一时刻维护两棵 fiber 树:
| 树 | 变量 | 角色 |
|---|---|---|
| current 树 | currentRoot | 上一次提交的,正显示在屏幕上 |
| wip 树 | wipRoot(work in progress) | 本次在内存中构建,可随时中断、丢弃、重来 |
alternate 就是两棵树之间的桥:每个新 fiber 通过 alternate 指向旧树中”同位置的上一代 fiber”。
function render(element, container) { wipRoot = { dom: container, props: {children: [element]}, alternate: currentRoot // 入口处挂上旧树的引用 } deletions = [] nextUnitOfWork = wipRoot}当 render 阶段的所有工作单元完成(nextUnitOfWork 为空且 wipRoot 存在),进入 commit 阶段,一次性、不可中断地把变更应用到 DOM:
function commitRoot() { deletions.forEach(commitWork) // 先删除 commitWork(wipRoot.child) // 再提交整棵新树 currentRoot = wipRoot // 双缓冲交换:新树升级为 current wipRoot = null}提交完成后 currentRoot = wipRoot,刚建好的树成为”当前树”,在下一次更新中它又成为 alternate 指向的对象。这个”绘制一帧 → 交换缓冲”的模式与游戏渲染中的 double buffering 完全同构。
7. Step VI:Reconciliation —— diff 算法
这是整个机制的核心。目标:更新时复用能复用的 DOM,只修改必须修改的部分。
处理某个 fiber 时,需要把它的新 children(elements 数组)与旧 children(旧 fiber 的 sibling 链表)逐对比较。alternate 在这里发挥关键作用——通过它从”新 fiber”跳到”旧树同位置节点”,再取其第一个孩子:
function reconcileChildren(wipFiber, elements) { let index = 0 let oldFiber = wipFiber.alternate && wipFiber.alternate.child let prevSibling = null
while (index < elements.length || oldFiber != null) { let element = elements[index] const sameType = oldFiber && element && oldFiber.type === element.type
if (sameType) { // ① 类型相同:复用 DOM,标记 UPDATE newFiber = { type: oldFiber.type, props: element.props, dom: oldFiber.dom, // ★ 复用旧 DOM 节点 alternate: oldFiber, effectTag: 'UPDATE' } } if (element && !sameType) { // ② 有新元素:全新创建,标记 PLACEMENT newFiber = { type: element.type, props: element.props, dom: null, alternate: null, effectTag: 'PLACEMENT' } } if (oldFiber && !sameType) { // ③ 旧节点多余:标记 DELETION oldFiber.effectTag = 'DELETION' deletions.push(oldFiber) // 不进新树,放进侧通道数组 }
if (oldFiber) oldFiber = oldFiber.sibling // 双指针同步前进 // ...把 newFiber 挂到新树的 child/sibling 链表上 index++ }}要点解读:
- 比较策略只有一个:****
type是否相同。这是 React diff 的核心启发式——同层比较 + 类型判断,把 O(n³) 的树对比降到了 O(n)。 - DELETION 不进新树:新树只包含”将来应该存在”的节点,被删的旧 fiber 只能靠单独的
deletions数组带到 commit 阶段,这也是为什么commitRoot要先处理它。 - UPDATE 的 DOM 复用:
dom: oldFiber.dom,整棵 DOM 子树原封不动保留,只 diff 属性。
属性 diff 由 updateDom 完成,四步各司其职:
function updateDom(dom, prevProps, nextProps) { // 1. 移除消失或变化的事件监听:removeEventListener // 2. 移除消失的属性:dom[name] = '' // 3. 设置新增/变化的属性:dom[name] = nextProps[name] // 4. 绑定新增/变化的事件监听:addEventListener}commit 阶段的 commitWork 根据 effectTag 执行对应操作:
if (fiber.effectTag === 'PLACEMENT' && fiber.dom != null) { domParent.appendChild(fiber.dom)} else if (fiber.effectTag === 'UPDATE' && fiber.dom != null) { updateDom(fiber.dom, fiber.alternate.props, fiber.props) // alternate 的第三处用途} else if (fiber.effectTag === 'DELETION') { commitDeletion(fiber, domParent)}至此 alternate 的三处用途全部集齐:render 入口挂链 → reconcile 跨树取旧 → commit 拿旧 props 做 diff。
8. Step VII:函数组件 —— 没有 DOM 的 fiber
函数组件带来了三个连锁变化:
变化一:fiber 的 type 可能是函数。函数组件没有自己的 DOM 节点,它的 children 是执行这个函数的返回值:
function updateFunctionComponent(fiber) { wipFiber = fiber hookIndex = 0 wipFiber.hooks = [] const children = [fiber.type(fiber.props)] // type 就是组件函数本身 reconcileChildren(fiber, children)}变化二:PLACEMENT 时父节点可能没有 dom。比如 <App/> 的子节点要插入时,fiber.parent 是 App 的 fiber,它没有 dom。所以 commitWork 要向上找到最近的有 dom 的祖先:
let domParentFiber = fiber.parentwhile (!domParentFiber.dom) { domParentFiber = domParentFiber.parent}const domParent = domParentFiber.dom变化三:DELETION 时被删的 fiber 也可能没有 dom。要向下递归找到第一个有 dom 的后代来 remove:
function commitDeletion(fiber, domParent) { if (fiber.dom) { domParent.removeChild(fiber.dom) } else { commitDeletion(fiber.child, domParent) }}9. Step VIII:Hooks —— useState 的实现
这是全文最精妙的部分,核心只有二十几行:
let wipFiber = nulllet hookIndex = null
function useState(initial) { // 1. 通过 alternate 找到上一次渲染时同位置的 hook const oldHook = wipFiber.alternate && wipFiber.alternate.hooks && wipFiber.alternate.hooks[hookIndex]
const hook = { state: oldHook ? oldHook.state : initial, // 有旧 hook 就继承 state queue: [] }
// 2. 把上次渲染以来排队的 action 依次应用到 state 上 const actions = oldHook ? oldHook.queue : [] actions.forEach(action => { hook.state = action(hook.state) })
// 3. setState 不直接改值:推入队列 + 触发新一轮渲染 const setState = action => { hook.queue.push(action) wipRoot = { dom: currentRoot.dom, props: currentRoot.props, alternate: currentRoot } nextUnitOfWork = wipRoot // workLoop 下一轮空闲时开始渲染 deletions = [] }
wipFiber.hooks.push(hook) // 4. 按调用顺序存入 hooks 数组 hookIndex++ return [hook.state, setState]}理解了这段代码,React Hooks 的两个”玄学规则”就全部可解释了:
- state 为什么能在多次渲染之间保留? 每次渲染时,
updateFunctionComponent把wipFiber.hooks重置为空数组,然后组件函数按顺序执行useState,通过hookIndex从alternate.hooks[hookIndex]取出上一次的 hook —— state 挂在 fiber 上,跟着 alternate 在两棵树之间传递。 - 为什么 Hooks 不能写在 if/for 里? 因为新旧 hook 的对应关系完全依赖调用顺序(index),没有 key 也没有名字。一旦某次渲染少调了一个 hook,后面所有 hook 的索引就整体错位,state 全部错乱。
- setState 为什么不立即生效? 它只是把一个 action 函数推入
hook.queue,然后设置wipRoot触发重渲染;真正计算新 state 是在下一次渲染执行到useState时,把队列里的 action 依次折叠(fold)到旧 state 上。
11. React 原理面试题(附参考答案)
Q1. JSX 是什么?编译后变成什么?
JSX 是语法糖,Babel 编译后变成 React.createElement(type, props, ...children) 的函数调用,返回值是普通的 JS 对象(element)—— { type, props: { children } }。它不是 DOM,只是对 UI 结构的描述。这也是 React 能跨平台(DOM/Native/Canvas)的原因:描述与渲染目标解耦。
Q2. 虚拟 DOM 一定比直接操作 DOM 快吗?
不一定。虚拟 DOM 有 diff 计算和对象创建的开销。它的真正价值是:声明式编程模型(开发者描述”结果”而不是”步骤”)、批量最小化更新(避免手动操作时的过度 reflow)、以及跨平台抽象。说”虚拟 DOM 快”是误解,准确的说法是:它以可接受的 diff 成本换来了开发效率和更新正确性。
Q3. 为什么 React 16 要用 Fiber 重写 reconciler?
旧版 Stack reconciler 用递归同步遍历整棵树,一旦开始不可中断:大组件树渲染会长时间阻塞主线程,动画、输入响应全部掉帧,也无法表达任务优先级。Fiber 把渲染拆成一个个可中断的工作单元(fiber 节点),用 parent/child/sibling 链表替代递归调用栈,配合调度器实现时间切片——高优先级更新(如输入)可以打断低优先级更新(如大列表渲染)。
Q4. Fiber 节点的关键字段有哪些?
Didact 简化版:type、props、dom(真实 React 叫 stateNode)、parent(return)、child、sibling、alternate、effectTag(真实 React 叫 flags)、hooks。其中 return/child/sibling 支撑可中断遍历,alternate 支撑双缓冲,flags 标记副作用类型(Placement/Update/Deletion)。
Q5. render 阶段和 commit 阶段有什么区别?为什么 commit 必须同步?
render 阶段在内存中构建 workInProgress 树、计算差异,纯计算、无副作用、可中断可丢弃;commit 阶段把变更写入真实 DOM,有副作用、必须一口气完成——否则用户会看到半新半旧的撕裂 UI,且中断后也无法从一致的中间状态恢复。真实 React 的 commit 还细分为 beforeMutation / mutation / layout 三个子阶段。
Q6. 什么是双缓存(double buffering)?alternate 的作用?
React 同时维护两棵 fiber 树:current(对应屏幕上显示的 UI)和 workInProgress(内存中构建中的下一帧)。每个 fiber 通过 alternate 指向另一棵树上的”自己”。构建完成后交换指针,workInProgress 成为 current。作用:① 渲染可中断可丢弃,不影响屏幕内容;② 新旧树对应节点可互相访问,用于 diff 比较与 state 继承(hooks 的 oldHook 就是靠 alternate 取的)。
Q7. React diff 算法的核心策略是什么?
三条启发式规则,把 O(n³) 降到 O(n):
- Tree diff:只同层比较,不跨层移动节点——跨层移动直接视为”删除旧的 + 创建新的”;
- Component/Element diff:类型不同直接销毁重建,类型相同则复用并更新 props(对应 Didact 的
sameType判断); - Element diff:通过 key 标识同层子元素,实现复用与移动(Didact 没实现 key 和移动,真实 React 靠 key 做移动优化)。
Q8. 为什么列表需要 key?用 index 做 key 有什么问题?
key 让 React 在两次渲染间识别”哪个元素还是哪个元素”,从而复用 DOM 和组件状态。用 index 做 key 时,如果列表发生插入、删除、排序,元素与 index 的对应关系会错位:React 会错误地复用 DOM 和内部状态(比如输入框内容串行、动画错乱),同时把本可”移动”的操作退化成大量”更新”,性能也更差。静态列表用 index 无伤大雅,动态列表必须用稳定唯一 id。
Q9. setState 是同步还是异步的?
要分版本和场景:
- React 17 及之前:在 React 事件处理器和生命周期中是”异步表现”(实际是批量更新,多次 setState 合并为一次渲染);在
setTimeout、原生事件中是同步的。 - React 18+:
createRoot下自动批处理(automatic batching),所有场景(包括 promise、setTimeout)都默认合并更新。
从 Didact 的实现可以直观理解其本质:setState 只是把 action 推入队列并调度一次新的渲染,state 的计算发生在下一次渲染执行 useState 时——所以”在 setState 之后立刻读 state 读到的是旧值”。
Q10. Hooks 为什么不能写在条件或循环里?
Hooks 的状态通过**调用顺序(索引)**与 fiber 上的 hooks 数组对应——useState 执行时按 hookIndex++ 从 alternate.hooks[hookIndex] 取上一次的 hook。这个对应关系没有任何名字或 key 做锚定。如果把 hook 写进条件分支,不同渲染间 hook 的调用数量和顺序发生变化,索引整体错位,所有 state 就会张冠李戴。同理,Hooks 也不能写在普通函数里,必须在组件函数(或自定义 Hook)的顶层调用。
Q11. React 事件是原生 DOM 事件吗?
不是。真实 React 使用合成事件(SyntheticEvent):事件统一委托挂载(React 16 及之前委托到 document,17 起委托到 root container),监听到原生事件后包装成跨浏览器一致的合成事件,再按组件树模拟冒泡分发。好处:抹平浏览器差异、便于和渲染优先级系统整合、避免在每个节点上绑定大量监听器。我们实现的 Didact 做了简化——直接把 onXxx 映射到原生 addEventListener,所以踩过 onChange(原生 change 是失焦触发)与 React 语义不一致的坑。
Q12. requestIdleCallback 有什么缺陷?React 为什么自研 Scheduler?
① 触发频率无保障:浏览器在忙(持续绘制 60fps)时 rIC 每帧最多触发一次,空闲时也可能 50ms 才触发一次,对高优先级任务太滞后;② 兼容性(当时 Safari 不支持);③ 没有优先级概念,无法插队。React 因此实现了自己的 Scheduler,用 MessageChannel 做宏任务调度,配合优先级队列(lane/expirationTime 模型)决定哪个任务先执行。
12. 总结
回顾整个实现,Didact 的每一行代码都对应着 React 的一个设计决策:
JSX 语法糖 → createElement:UI 即数据(element 对象)递归 render 不可中断 → Fiber:链表化树结构,渲染变成可暂停的工作单元主线程抢占 → 时间切片:requestIdleCallback + workLoop半成品的 UI 撕裂 → 双缓冲:current / wipRoot / alternate全量重建 DOM 太贵 → Reconciliation:sameType 启发式 diff + effectTag函数组件没有 DOM → commit 阶段向上找 domParent、向下递归删除跨渲染保存状态 → Hooks:fiber 上的 hooks 数组 + action 队列下一步可以继续探索的方向:给 reconcile 加 key 支持和节点移动、实现 useEffect(依赖数组比对 + commit 后调度)、实现 Context,或者去读 React 源码中 ReactFiberWorkLoop 与 beginWork/completeWork 的真实实现——你会发现 Didact 的 performUnitOfWork 就是它们的极简版。
参考
支持与分享
如果这篇文章对你有帮助,欢迎分享给更多人或打赏支持!




