Jw
首页
技术
英语
首页
技术
英语
  • 01-权衡的艺术

    • 1.1 命令式与声明式
    • 1.2 性能与可维护性的权衡
    • 1.3 虚拟DOM的性能到底如何
    • 1.4 运行时和编译时
  • 02-框架设计的核心要素

    • 2.1 提升用户的开发体验
    • 2.2 控制框架代码的体积
    • 2.3 框架要做到良好的 Tree-Shaking
    • 2.4 框架应该输出怎样的构建产物
    • 2.5 特性开关
    • 2.6 错误处理
    • 2.7 良好的 TypeScript 类型支持
  • 03-Vue.js 3 的设计思路

    • 3.1 声明式地描述UI
    • 3.2 初识渲染器
    • 3.3 组件的本质
    • 3.4 模板的工作原理
    • 3.5 Vue.js 是各个模块组成的有机整体
  • 04-响应系统的作用与实现

    • 4.1 响应式数据与副作用函数
    • 4.2 响应式数据的基本实现
    • 4.3 设计一个完善的响应系统
    • 4.4 分支切换与 cleanup
    • 4.5 嵌套的effect与effect栈
    • 4.6 避免无限递归循环
    • 4.7 调度执行
    • 4.8 计算属性 computed 与 lazy
    • 4.9 watch 的实现原理
    • 4.10 立即执行的 watch 与回调执行时机
    • 4.11 过期的副作用
  • 05-非原始值的响应式方案

    • 5.1 理解 Proxy 和 Reflect
    • 5.2 JavaScript 对象及 Proxy 的工作原理
    • 5.3 如何代理 Object
    • 5.4 合理地触发响应
    • 5.5 浅响应与深响应
    • 5.6 只读和浅只读
    • 5.7 代理数组
    • 5.7.1 数组的索引与 length
    • 5.7.2 遍历数组
    • 5.7.3 数组的查找方法
    • 5.7.4 隐式修改数组长度的原型方法
    • 5.8 代理 Set 和 Map
    • 5.8.1 如何代理Set和Map
    • 5.8.2 建立响应联系
    • 5.8.3 避免污染原始数据
    • 5.8.4 处理forEach
    • 5.8.5 迭代器方法
    • 5.8.6 values与keys方法
  • 06-原始值的响应式方案

    • 6.1 引入 ref 的概念
    • 6.2 响应丢失问题
    • 6.3 自动脱ref
  • 07-渲染器的设计

    • 7.1 渲染器与响应系统的结合
    • 7.2 渲染器的基本概念
    • 7.3 自定义渲染器
  • 08-挂载与更新

    • 8.1 挂载子节点和元素的属性
    • 8.2 HTML Attributes 与 DOM Properties
    • 8.3 正确地设置元素属性
    • 8.4 class的处理
    • 8.5 卸载操作
    • 8.6 区分vnode类型
    • 8.7 事件的处理
    • 8.8 事件冒泡与更新时机问题
    • 8.9 更新子节点
    • 8.10 文本节点和注释节点
    • 8.11 Fragment
  • 09-简单 Diff 算法

    • 9.1 减少 DOM 操作的性能开销
    • 9.2 DOM 复用与 key 的作用
    • 9.3 找到需要移动的元素
    • 9.4 如何移动元素
    • 9.5 添加新元素
    • 9.6 移除不存在的元素
  • 10-双端 Diff 算法

    • 10.1 双端比较的原理
    • 10.3 非理想状况的处理方式
    • 10.4 添加新元素
    • 10.5 移除不存在的元素
  • 11-快速 Diff 算法

    • 11.1 相同的前置元素和后置元素
    • 11.2 判断是否需要进行 DOM 移动操作
    • 11.3 如何移动元素
  • 12-组件的实现原理

    • 12.1 渲染组件
    • 12.2 组件状态与自更新
    • 12.3 组件实例与组件的生命周期
    • 12.4 props与组件的被动更新
    • 12.5 setup 函数的作用与实现
    • 12.6 组件事件与 emit 的实现
    • 12.7 插槽的工作原理与实现
    • 12.8 注册生命周期
  • 13-异步组件与函数式组件

    • 13.1 异步组件要解决的问题
    • 13.2.1 封装defineAsyncComponent函数
    • 13.2.2 超时与 Error 组件
    • 13.2.3 延迟与 Loading 组件
    • 13.2.4 重试机制
    • 13.3 函数式组件
  • 14-内建组件和模块

    • 14.1.1 组件的激活与失活
    • 14.1.2 include 和 exclude
    • 14.1.3 缓存管理
    • 14.2.1 Teleport 组件要解决的问题
    • 14.2.2 实现 Teleport 组件
    • 14.3.1 原生 DOM 的过渡
    • 14.3.2 实现 Transition 组件
  • 15-编译器核心技术概览

    • 15.1 模板 DSL 的编译器
    • 15.2 parser 的实现原理与状态机
    • 15.3 构造AST
    • 15.4 AST 的转换与插件化架构
    • 15.4.1 节点的访问
    • 15.4.2 转换上下文与节点操作
    • 15.4.3 进入与退出
    • 15.5 将模板 AST 转为 JavaScript AST
    • 15.6 代码生成
  • 16-解析器

    • 16.1 文本模式及其对解析器的影响
    • 16.2 递归下降算法构造模板 AST
    • 16.3 状态机的开启与停止
    • 16.4 解析标签节点
    • 16.5 解析属性
    • 16.6.1 解析文本
    • 16.6.2 解码命名字符引用
    • 16.6.3 解码数字字符引用
    • 16.7 解析插值与注释
  • 17-编译优化

    • 17.1.1 传统Diff算法问题
    • 17.1.2 Block 与 PatchFlags
    • 17.1.3 收集动态节点
    • 17.1.4 渲染器的运行时支持
    • 17.2.1 带有 v-if 指令的节点
    • 17.2.2 带有 v-for 指令的节点
    • 17.2.3 Fragment 的稳定性
    • 17.3 静态提升
    • 17.4 预字符串化
    • 17.5 缓存内联事件处理函数
    • 17.6 v-once
  • 18-同构渲染

    • 18.1 CSR、SSR 以及同构渲染
    • 18.2 将虚拟 DOM 渲染为 HTML 字符串
    • 18.3 将组件渲染为 HTML 字符串
    • 18.4 客户端激活的原理
    • 18.5.1 组件的生命周期
    • 18.5.2 使用跨平台的 API
    • 18.5.3 只在某一端引入模块
    • 18.5.4 避免交叉请求引起的状态污染
    • 18.5.5 ClientOnly 组件

15.4.2 转换上下文与节点操作

context 是转换过程中的「全局变量」,所有转换函数靠它共享数据;节点的替换与删除也必须借助它提供的 replaceNode / removeNode。

一、什么是转换上下文

  • 上下文不是一个具象的东西,它依赖于具体的使用场景。
  • 上下文对象其实就是程序在某个范围内的「全局变量」;反过来说,全局变量也可以看作全局上下文。
  • 所有 AST 转换函数都可以通过 context 来共享数据。

二、context 上的数据

字段含义设置时机
currentNode当前正在转换的节点每次进入 traverseNode 时置为 ast
parent当前节点的父节点递归转换子节点之前设为当前节点
childIndex当前节点在父节点 children 中的位置索引递归前设为循环下标 i
nodeTransforms注册的转换函数数组在 transform 内初始化
replaceNode替换当前节点的函数同上
removeNode删除当前节点的函数同上
helpers生成代码时需要注入的辅助函数(如 h),通过 addHelper 收集完整实现中使用
sourceLocation节点在源码中的位置信息,用于报错时定位解析阶段写入节点,转换阶段读取
function traverseNode(ast, context) {
  // 设置当前转换的节点信息 context.currentNode
  context.currentNode = ast

  const transforms = context.nodeTransforms
  for (let i = 0; i < transforms.length; i++) {
    transforms[i](context.currentNode, context)
  }

  // 递归转换子节点
  const children = context.currentNode.children
  if (children) {
    for (let i = 0; i < children.length; i++) {
      // 递归之前,把当前节点设为父节点,并记录位置索引
      context.parent = context.currentNode
      context.childIndex = i
      traverseNode(children[i], context) // 透传 context
    }
  }
}

function transform(ast) {
  const context = {
    currentNode: null,   // 当前正在转换的节点
    childIndex: 0,       // 当前节点在父节点 children 中的索引
    parent: null,        // 当前转换节点的父节点
    nodeTransforms: [transformElement, transformText]
  }

  traverseNode(ast, context)
  console.log(dump(ast))
}

易错点:parent 与 childIndex 必须在递归子节点之前设置;若放在递归之后,转换函数里拿到的就是上一轮遗留的值。

三、replaceNode:为什么不能直接赋值

需求:转换时希望把某些节点替换为其他类型的节点。

// 用于替换节点的函数,接收新节点作为参数
replaceNode(node) {
  // 替换的本质是修改 AST:
  // 找到当前节点在父节点 children 中的位置(context.childIndex),用新节点替换
  context.parent.children[context.childIndex] = node
  // 当前节点已被替换,同步把 currentNode 指向新节点
  context.currentNode = node
}
  • 为什么要改 context.parent.children[childIndex]:父子关系靠父节点 children 数组中的引用维持。只让局部变量 currentNode 指向新节点,父节点 children 里指向的仍是旧节点,后续的遍历与代码生成拿到的还是旧节点,替换等于没生效。
  • 替换之后要同步更新 context.currentNode,否则后续转换函数操作的还是那个已被丢弃的旧节点。
function transformText(node, context) {
  if (node.type === 'Text') {
    // 把文本节点替换为元素节点
    context.replaceNode({ type: 'Element', tag: 'span' })
  }
}

// 测试:遍历是深度优先的,若「文本外再套一层标签」,
// 会导致后续节点的 parent 变化、替换失败,所以用结构简单的模板测试
const ast = parse(`<div>hello<p>vue</p></div>`)
transform(ast)

四、removeNode:删除后必须中断后续处理

// 用于删除当前节点
removeNode() {
  if (context.parent) {
    // 根据当前节点的索引,从父节点的 children 中删除当前节点
    context.parent.children.splice(context.childIndex, 1)
    // 将 currentNode 置空,作为「已被删除」的标记
    context.currentNode = null
  }
}
  • 任何转换函数都可能移除当前访问的节点,因此每个转换函数执行完毕后都要检查 context.currentNode 是否还存在,不存在则 traverseNode 直接返回,不做后续处理:
for (let i = 0; i < transforms.length; i++) {
  transforms[i](context.currentNode, context)
  // 当前节点被移除了 → 直接返回
  if (!context.currentNode) return
}
function transformText(node, context) {
  if (node.type === 'Text') {
    // 直接移除文本节点
    context.removeNode()
  }
}

// 测试
const ast = parse(`<div>hello<p>vue</p></div>`)
transform(ast)

易错点:splice 会改变原数组的长度,若用 for 循环遍历 children,删除后索引会错乱(与 hello 相邻的 p 可能被跳过),循环需要做相应修正。 补充:转换函数可以返回退出阶段的回调(见 15.4.3),节点被移除时应直接返回,这些回调也不会再执行。

相关

  • 15.4.1 节点的访问:先能遍历到节点,才有「当前节点」可替换/删除
  • 15.4.3 进入与退出:转换函数返回值(退出阶段回调)的来龙去脉
最近更新: 2026/10/12 00:05
Contributors: liujw
Prev
15.4.1 节点的访问
Next
15.4.3 进入与退出