视频加载失败

Mini-React实现

4635 字
23 分钟
Mini-React实现

手写一个迷你 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
真实 DOM

2. 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: []}
}
}

两个设计细节:

  1. element 只有两个字段:type(标签名或组件函数)和 props(含 children)。children 是数组,天然支持任意嵌套。
  2. 文本节点统一包成 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.parent
while (!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 = null
let 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 的两个”玄学规则”就全部可解释了:

  1. state 为什么能在多次渲染之间保留? 每次渲染时,updateFunctionComponent 把 wipFiber.hooks 重置为空数组,然后组件函数按顺序执行 useState,通过 hookIndex 从 alternate.hooks[hookIndex] 取出上一次的 hook —— state 挂在 fiber 上,跟着 alternate 在两棵树之间传递。
  2. 为什么 Hooks 不能写在 if/for 里? 因为新旧 hook 的对应关系完全依赖调用顺序(index),没有 key 也没有名字。一旦某次渲染少调了一个 hook,后面所有 hook 的索引就整体错位,state 全部错乱。
  3. 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):

  1. Tree diff:只同层比较,不跨层移动节点——跨层移动直接视为”删除旧的 + 创建新的”;
  2. Component/Element diff:类型不同直接销毁重建,类型相同则复用并更新 props(对应 Didact 的 sameType 判断);
  3. 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 就是它们的极简版。

参考#

支持与分享

如果这篇文章对你有帮助,欢迎分享给更多人或打赏支持!

打赏
Mini-React实现
https://firefly.cuteleaf.cn/posts/-mini_react实现/
作者
MIRAI
发布于
2026-10-30
许可协议
CC BY-NC-SA 4.0

评论区

Profile Image of the Author
MIRAI
心之所向,素履以往
公告
欢迎来到我的博客!
分类
标签
最新动态
站点统计
文章
11
分类
1
标签
10
总字数
19,512
运行时长
0 天
最后活动
0 天前
站点信息
构建平台
GitHub Actions
博客版本
Firefly v6.16.8
文章许可
CC BY-NC-SA 4.0
文章目录