罗罗编程学习记录
本页内容 展开查看

03.4.2.1 响应式原理与模板编译

所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.4 前端框架 / 03.4.2 Vue

03.4.2.1-001 Vue 3 响应式整体思路是什么?

一句话结论

Vue 3 用 Proxy 代理对象,读取时 track 收集依赖,修改时 trigger 通知关联副作用重新执行;响应式系统在对象访问与变更节点上拦截,自动驱动视图更新。

概念解释

  • 响应式:数据变化后依赖它的视图/计算自动更新,无需手动操作 DOM。
  • 依赖:读取过该数据的副作用(组件渲染、watch、computed)。
  • Proxy 替代 Vue 2 的 Object.defineProperty,可监听新增/删除属性与数组索引变化。

原理流程

  1. 目标对象被 reactive/ref 包装为代理。
  2. 渲染/副作用读取属性,track 记录当前副作用与属性映射。
  3. 属性被修改,trigger 找到对应副作用队列并调度更新。

代码 / 示例

import { reactive, watch } from "vue";

const state = reactive({ count: 0 });
watch(
  () => state.count,
  (v) => console.log("count =", v)
);
state.count++; // 触发 trigger,watch 回调执行

常见误区

  • 误区:响应式是给对象属性加 setter 就能自动更新 DOM;正解:还需要依赖收集、副作用调度与组件渲染链路配合。
  • 误区:Proxy 代理后原始对象也变响应式;正解:代理是包装层,原始对象普通读取不会触发收集。

追问

  • Q:Proxy 相比 defineProperty 解决了什么? A:能监听属性新增/删除、数组索引与长度变化,无需递归预定义全部属性。
  • Q:响应式系统在浏览器与 SSR 中行为一致吗? A:SSR 服务端不执行视图副作用,具体调度行为按 Vue 3.x 版本确认。

03.4.2.1-002 reactive 如何代理对象,有哪些局限?

一句话结论

reactive 接收普通对象/数组/集合,返回深层 Proxy 代理;对象属性读取与写入被拦截并参与依赖收集,局限是不能直接替换整体、解构丢失响应性、原始类型无法使用。

概念解释

  • 深层代理:嵌套对象访问时返回其代理。
  • 支持数组、Map、Set 等集合类型的拦截处理。
  • 返回的是代理对象,与原始对象引用不相等。

原理流程

  1. 调用 reactive 建立 Proxy 处理器。
  2. get 拦截:返回嵌套代理并 track。
  3. set/deleteProperty 拦截:写入后 trigger。

代码 / 示例

const form = reactive({ name: "", profile: { age: 0 } });
form.profile.age = 18; // 嵌套访问同样被代理拦截

// 局限:整体替换会丢失代理
// form = reactive({ name: "x" }); // 不允许直接赋值

常见误区

  • 误区:reactive 可以包装字符串/数字;正解:原始类型需用 ref,reactive 只处理对象类型。
  • 误区:把 reactive 对象解构后字段仍响应式;正解:解构出的是普通值,需 toRefs 保持引用。

追问

  • Q:如何拿到 reactive 对应的原始对象? A:使用 toRaw 获取底层原始对象,避免代理开销或绕过响应式。
  • Q:reactive 数组直接改索引能触发更新吗? A:Vue 3 对数组索引与长度变更做了拦截处理,具体行为按版本确认。

03.4.2.1-003 ref 的实现原理是什么?

一句话结论

ref 用一个带 .value 的包装对象承载任意类型值:原始类型靠包装对象保存响应式,对象类型内部再走 reactive 代理;模板中 ref 自动解包,脚本中必须通过 .value 访问。

概念解释

  • ref 解决原始类型无法被 Proxy 代理的问题。
  • .value 读取触发 track,写入触发 trigger。
  • 对象 ref 的 .value 是 reactive 代理。

原理流程

  1. 创建 ref 包装对象,保存内部值。
  2. 读取 .value:track 依赖,对象值返回代理。
  3. 写入 .value:更新内部值并 trigger 通知。

代码 / 示例

const count = ref(0);
const list = ref<string[]>([]);

console.log(count.value); // 脚本中需 .value
count.value++;

// 模板中自动解包:{{ count }} 等价于 count.value

常见误区

  • 误区:脚本里直接写 count 就能拿到值;正解:setup/脚本上下文必须访问 .value,模板才自动解包。
  • 误区:ref 包装对象本身需要 reactive;正解:ref 内部已实现响应式读写拦截。

追问

  • Q:ref 放在 reactive 对象里会自动解包吗? A:作为 reactive 顶层属性时访问 .value 自动解包,嵌套规则按文档确认。
  • Q:shallowRef 与 ref 区别? A:shallowRef 只对 .value 整体替换响应式,内部对象不做深层代理。

03.4.2.1-004 ref 与 reactive 如何选择?

一句话结论

原始类型、需要整体替换的值、独立字段用 ref;结构固定的对象表单/状态用 reactive;实践中组合式 API 常以 ref 为主,避免解构丢失与整体替换问题。

概念解释

  • ref:值语义清晰,可整体替换,模板自动解包。
  • reactive:对象语义,属性访问直接,但解构与替换受限。
  • 选择以数据形态与更新方式为准。

原理流程

  1. 判断值是原始类型还是对象。
  2. 需要整体替换用 ref。
  3. 对象结构稳定、按字段更新可选用 reactive。

代码 / 示例

// 原始类型 / 整体替换:ref
const loading = ref(false);
const list = ref<Item[]>([]);

// 固定结构对象:reactive
const form = reactive({ name: "", email: "" });

常见误区

  • 误区:对象一律用 reactive;正解:列表整体替换、对象字段独立管理时 ref 更顺手。
  • 误区:reactive 解构后用 toRefs 是多余步骤;正解:不解构直接访问属性可省略,跨函数/模板传递解构值时才需要。

追问

  • Q:组合式 API 社区惯例偏向哪种? A:多数业务代码以 ref 为主,reactive 用于表单等固定对象,具体团队约定按项目确认。
  • Q:ref 对象类型内部是 reactive 吗? A:是,对象值通过 reactive 代理,深层属性访问保持响应式。

03.4.2.1-005 track 与 trigger 的执行流程是什么?

一句话结论

track 在副作用读取响应式属性时记录“属性 → 依赖副作用”映射;trigger 在属性变更时按映射取出关联副作用并排队调度,实现数据到视图的自动更新。

概念解释

  • 依赖收集发生在读取阶段,而非声明阶段。
  • 一个属性可被多个副作用依赖,一个副作用可依赖多个属性。
  • 调度阶段批量执行副作用,避免重复刷新。

原理流程

  1. 当前正在执行的副作用(渲染/watch)进入依赖上下文。
  2. 读取属性时 track 把副作用加入该属性的依赖集合。
  3. 写入属性时 trigger 收集依赖副作用,调度器排队执行。

代码 / 示例

读取 state.count
  → track(target, key="count")
  → 依赖集合记录当前渲染副作用

写入 state.count = 1
  → trigger(target, key="count")
  → 取出依赖副作用 → 队列调度 → 重新渲染/执行 watch

常见误区

  • 误区:不读取也能被收集为依赖;正解:只有在副作用执行期间访问过的属性才进入依赖映射。
  • 误区:trigger 同步立即重渲染所有组件;正解:副作用进入调度队列,按批次与优先级执行。

追问

  • Q:如何避免不必要的依赖收集? A:在副作用外读取常量、用浅响应式或拆分状态,减少单副作用依赖面。
  • Q:Map/Set 的依赖键如何记录? A:集合操作按容器与键值记录依赖,具体内部数据结构按 Vue 源码版本确认。

03.4.2.1-006 副作用函数与更新调度如何工作?

一句话结论

组件渲染、computed 重算、watch 回调都包装为副作用函数;响应式变更触发调度,副作用排队执行并在执行时重新收集依赖,形成可重复运行的更新闭环。

概念解释

  • 副作用首次执行时建立依赖。
  • 依赖变化后重新执行,执行过程中重新收集最新依赖。
  • 调度器合并同一轮多次变更,避免重复执行。

原理流程

  1. 副作用首次运行,读取响应式数据并收集依赖。
  2. 依赖变更 trigger 调度副作用。
  3. 副作用重跑,刷新结果与依赖集合。

代码 / 示例

const a = ref(1);
const b = ref(2);
const sum = computed(() => a.value + b.value);

watch(sum, (v) => console.log(v));
a.value = 3; // 调度 computed 重算 → watch 触发

常见误区

  • 误区:副作用依赖一旦收集就固定不变;正解:每次重跑都会重新收集,条件分支中的依赖可随执行路径变化。
  • 误区:每次属性写入都同步执行所有依赖组件;正解:调度合并批次,具体刷新时机按 Vue 版本确认。

追问

  • Q:computed 与普通 watch 副作用区别? A:computed 有缓存与惰性求值,依赖不变不重算。
  • Q:副作用执行报错如何隔离? A:按错误边界与错误处理机制捕获,避免整树更新中断。

03.4.2.1-007 解构 reactive 为什么丢失响应性,如何修复?

一句话结论

解构 reactive 对象得到的是普通值快照,与代理断开引用;用 toRefs 把每个属性转为 ref,或 toRef 取单个属性,保持对代理的响应式引用。

概念解释

  • 解构执行一次取值,原始类型字段成为普通常量。
  • 对象字段解构后引用的是代理内对象,部分场景仍可间接响应,但字段替换会断开。
  • toRefs 生成与原属性联动的 ref。

原理流程

  1. reactive 对象属性被读取。
  2. 解构把当前值复制到局部变量。
  3. 后续修改代理属性,局部变量不更新;toRefs 包装后通过 .value 联动。

代码 / 示例

const form = reactive({ name: "", age: 0 });

// 丢失:name 是普通字符串
// const { name } = form;

// 保持响应式
const { name, age } = toRefs(form);
name.value = "Ann";

const ageRef = toRef(form, "age");

常见误区

  • 误区:解构对象字段后改局部变量会同步回代理;正解:普通值副本不会回写,需通过 ref 或原对象属性更新。
  • 误区:toRefs 对所有类型都必要;正解:不解构、直接访问 form.name 时不需要。

追问

  • Q:toRef 与 toRefs 区别? A:toRef 取单个属性,toRefs 批量把对象每个属性转 ref。
  • Q:从 props 解构为什么也建议用 toRefs? A:props 是响应式对象,解构会断开引用,详见 03.4.2.2。

03.4.2.1-008 shallow 系列与 readonly 响应式有什么区别?

一句话结论

shallowRef/shallowReactive 只在最外层建立响应式,内部对象不做深层代理;readonly 返回只读代理,读取可收集依赖,写入被拦截并告警;用于控制深度与保护状态。

概念解释

  • 浅响应式:内部嵌套变更不自动触发,需整体替换 .value。
  • 只读代理:禁止修改,常用于派生状态或对外暴露不可变视图。
  • 深层控制减少代理开销,适合大对象或外部引用对象。

原理流程

  1. shallow 只拦截顶层读写。
  2. 内部对象按原始引用使用,不递归代理。
  3. readonly 包装层拦截 set/delete,拒绝写入。

代码 / 示例

const state = shallowRef({ nested: { count: 0 } });
// state.value.nested.count = 1; // 不触发响应式
state.value = { nested: { count: 1 } }; // 整体替换才触发

const ro = readonly(form);
// ro.name = "x"; // 开发环境告警,写入被拦截

常见误区

  • 误区:shallowRef 内部对象修改会自动更新视图;正解:只有整体替换 .value 才触发。
  • 误区:readonly 在运行时完全阻止修改;正解:开发环境告警拦截,底层原始对象仍可被 toRaw 后修改。

追问

  • Q:什么时候用 shallow 系列? A:大对象、第三方库对象、内部由其他状态管理的场景,避免深层代理开销。
  • Q:readonly 与 Object.freeze 区别? A:readonly 是响应式只读代理,仍参与依赖收集;freeze 是运行时对象冻结,无响应式能力。

03.4.2.1-009 computed 的缓存与惰性求值原理是什么?

一句话结论

computed 基于响应式依赖惰性求值:依赖不变时返回缓存值,依赖变化后标记脏并在下次读取时重算;它返回只读 ref,不允许直接写入。

概念解释

  • 计算属性是派生状态,由其他响应式数据推导。
  • 缓存避免每次访问都重复计算。
  • 依赖收集与 track/trigger 机制同响应式系统。

原理流程

  1. 首次读取 computed,执行计算函数并缓存结果。
  2. 依赖变更标记为脏,通知下游。
  3. 下次读取时若为脏则重算,否则返回缓存。

代码 / 示例

const firstName = ref("Ann");
const lastName = ref("Lee");
const fullName = computed(() => `${firstName.value} ${lastName.value}`);

console.log(fullName.value); // 计算并缓存
firstName.value = "Anna";    // 标记脏,下次读取重算

常见误区

  • 误区:computed 每次访问都重新计算;正解:依赖不变时返回缓存值。
  • 误区:computed 可以像 ref 一样直接赋值;正解:默认只读,需写 getter/setter 才支持双向计算。

追问

  • Q:computed 如何定义可写计算属性? A:传 { get, set } 对象,set 中更新源状态。
  • Q:computed 与 watch 派生状态区别? A:computed 声明式派生且有缓存,watch 用于副作用与跨状态联动。

03.4.2.1-010 watch 与 watchEffect 有什么区别?

一句话结论

watch 显式指定监听源,回调能拿到新旧值,惰性执行(默认不立即跑);watchEffect 自动收集回调内读取的响应式依赖,立即执行一次,不直接提供旧值。

概念解释

  • watch:源可以是 ref、getter、数组;支持新旧值与深度配置。
  • watchEffect:执行体内部读取谁就依赖谁,首次立即运行。
  • 两者都返回停止函数,可清理副作用。

原理流程

  1. watch 注册监听源,源变化后回调执行并传新旧值。
  2. watchEffect 首次运行收集依赖,依赖变化后重跑。
  3. 停止函数取消监听与依赖。

代码 / 示例

const keyword = ref("");

watch(keyword, (newVal, oldVal) => {
  console.log("变化", oldVal, "→", newVal);
});

watchEffect(() => {
  console.log("关键词:", keyword.value); // 立即执行,自动收集
});

const stop = watchEffect(() => {});
stop(); // 手动停止

常见误区

  • 误区:watch 默认立即执行回调;正解:默认惰性,需 immediate: true 才首次执行。
  • 误区:watchEffect 能拿到旧值;正解:它只暴露当前值,需要新旧对比用 watch。

追问

  • Q:监听 reactive 对象需要写 getter 吗? A:直接传对象默认深度监听,需要精确新旧值时用 getter 函数,配置项按版本确认。
  • Q:副作用清理函数怎么写? A:回调返回清理函数,在下次执行前与停止时调用。

03.4.2.1-011 Vue 模板编译分为哪几个阶段?

一句话结论

模板编译经过解析(parse)生成 AST、转换(transform)做优化与指令处理、代码生成(codegen)输出渲染函数代码;最终渲染函数执行生成虚拟 DOM 描述。

概念解释

  • parse:把模板字符串解析为抽象语法树。
  • transform:遍历 AST,处理指令、静态标记与优化节点。
  • codegen:把 AST 转为 JS 渲染函数字符串。

原理流程

  1. 词法/语法分析生成 AST。
  2. 转换阶段打 PatchFlag、提升静态节点。
  3. 生成 render 函数,运行时产出 VNode。

代码 / 示例

模板:<div class="box">{{ count }}</div>
  → parse: AST(div/class/插值)
  → transform: 标记动态绑定
  → codegen: render 函数
  → 运行时:h(div, {class}, count)

常见误区

  • 误区:模板直接编译成真实 DOM;正解:先编译为渲染函数,运行时生成 VNode 再由运行时挂载为 DOM。
  • 误区:编译优化在浏览器运行时完成;正解:静态提升、PatchFlag 等在构建期模板编译阶段完成。

追问

  • Q:运行时编译与预编译区别? A:预编译在构建期生成 render 函数,运行时编译在浏览器现场编译,体积与性能权衡按项目确认。
  • Q:SFC 编译产物包含什么? A:script、模板渲染函数与样式块处理结果,具体打包形式按构建工具确认。

03.4.2.1-012 什么是静态提升与 PatchFlag?

一句话结论

静态提升把不变的模板节点提取为常量复用,避免每次渲染重复创建;PatchFlag 在编译期标记动态绑定类型,运行时 Diff 只对比带标记的动态部分,减少更新开销。

概念解释

  • 静态节点:不包含任何动态绑定的元素/文本。
  • 动态节点按绑定类型打标记(文本、class、props 等)。
  • 运行时只处理带 PatchFlag 的动态片段。

原理流程

  1. 编译期分析节点静态/动态属性。
  2. 静态节点提升为模块级常量。
  3. 动态节点打 PatchFlag,Diff 按标记定向更新。

代码 / 示例

模板:
  <header>固定标题</header>
  <p>{{ count }}</p>

编译优化:
  header 静态提升为常量
  p 标记 TEXT 动态标记,Diff 只更新文本

常见误区

  • 误区:PatchFlag 让 Diff 变成 O(1);正解:它缩小了需要对比的动态范围,节点遍历成本仍在。
  • 误区:所有静态内容都提升到模块外;正解:按编译器判断的静态边界提升,条件与插值节点保持动态。

追问

  • Q:事件绑定在编译期有缓存优化吗? A:稳定事件处理器可缓存内联函数,具体优化策略按 Vue 版本确认。
  • Q:PatchFlag 类型有哪些? A:文本、class、style、props、事件等分类标记,枚举细节按源码版本确认。

03.4.2.1-013 Vue 的 Diff 算法与 React 有何不同?

一句话结论

Vue 3 对子节点做双端比较(新旧头尾指针同时推进),结合最长递增子序列计算最少移动次数;React 依赖 key 从两端与位置映射复用,二者都只做同层比较。

概念解释

  • 双端比较:头对头、尾对尾、交叉比较。
  • 最长递增子序列:在需要移动的节点中找可保持原位的最长序列,减少 DOM 移动。
  • 都不跨层级搜索节点。

原理流程

  1. 同层比较新旧子节点。
  2. 头尾指针匹配相同 key 节点复用。
  3. 剩余节点按最长递增子序列计算插入/移动方案。

代码 / 示例

旧:A B C D
新:B A E C D

双端匹配 + LIS 计算:
  尽量原地复用,只移动必须移动的节点

常见误区

  • 误区:Vue Diff 全局搜索最长公共子序列;正解:双端比较 + 递增子序列局部优化,控制复杂度。
  • 误区:key 在 Vue 中可有可无;正解:无 key 按位置匹配,列表增删时同样容易错位复用。

追问

  • Q:为什么用最长递增子序列? A:长度最长的递增序列可保持原位不动,其余节点按序插入,减少移动操作。
  • Q:Vue 与 React 列表复用策略哪个更优? A:二者目标都是线性复杂度下减少操作,具体表现按场景与版本实测对比。

03.4.2.1-014 编译期对事件与插槽有哪些处理?

一句话结论

稳定内联事件处理器在编译期可缓存为复用函数,避免每次渲染新建;插槽编译为作用域插槽函数,父组件传作用域数据,子组件调用获取内容。

概念解释

  • 事件缓存减少函数引用变化带来的子组件更新。
  • 作用域插槽通过函数把子组件数据暴露给父级模板。
  • 插槽内容编译为可调用的渲染函数。

原理流程

  1. 模板中的事件绑定编译为处理器。
  2. 稳定处理器被缓存复用。
  3. 插槽编译为函数,子组件执行时传入插槽数据。

代码 / 示例

<Row :data="item">
  <template #default="{ item }">
    {{ item.name }}
  </template>
</Row>

常见误区

  • 误区:内联事件每次渲染都必然新建函数;正解:编译器可对稳定处理器做缓存,具体条件按版本确认。
  • 误区:作用域插槽数据由父组件持有;正解:子组件把内部数据通过插槽参数暴露给父级模板。

追问

  • Q:默认插槽与具名插槽区别? A:默认插槽无名称,具名插槽按名称分发多个内容区。
  • Q:插槽传函数与传数据区别? A:作用域插槽是子调子函数并传参,普通插槽是父级提供渲染内容。

03.4.2.1-015 响应式系统如何处理原始类型?

一句话结论

原始类型(string/number/boolean 等)无法被 Proxy 代理,统一通过 ref 包装对象的 .value 建立读写拦截;reactive 只接收对象类型。

概念解释

  • Proxy 代理目标必须是对象。
  • ref 用包装对象绕开原始类型限制。
  • 模板与 setup 上下文对 ref 做解包处理。

原理流程

  1. 原始值传入 ref 创建包装对象。
  2. .value get/set 拦截并参与 track/trigger。
  3. 模板渲染时自动解包读取内部值。

代码 / 示例

const name = ref("Ann");   // 字符串用 ref
const count = ref(0);      // 数字用 ref
// const bad = reactive(0); // 类型不允许

常见误区

  • 误区:可以用 reactive 包装数字;正解:类型系统与运行时都要求 reactive 入参为对象。
  • 误区:ref 包装的原始值在模板里还要写 .value;正解:模板顶层 ref 自动解包。

追问

  • Q:ref 嵌套在 reactive 对象中何时解包? A:顶层属性访问自动解包,深层嵌套规则按文档确认。
  • Q:模板解包对数组 ref 有效吗? A:数组 .value 在模板中按规则解包,具体边界以官方文档为准。

03.4.2.1-016 响应式代理与原始对象是什么关系?

一句话结论

reactive 返回 Proxy 包装层,底层保留原始对象;代理读写转发到原始对象,toRaw 可取回原始对象;代理与原始对象不相等,避免重复代理是内部优化之一。

概念解释

  • 同一原始对象多次 reactive 得到相同代理。
  • 代理上的属性操作落到原始对象存储。
  • 绕过代理直接改原始对象不会触发响应式更新。

原理流程

  1. reactive 检查是否已有代理缓存。
  2. 建立 Proxy 转发 get/set 到原始对象。
  3. toRaw 沿代理取到底层原始对象。

代码 / 示例

const raw = { count: 0 };
const proxy = reactive(raw);
console.log(proxy === raw);      // false
console.log(toRaw(proxy) === raw); // true

raw.count = 99; // 绕过代理,不触发 trigger

常见误区

  • 误区:修改原始对象也能触发视图更新;正解:只有经过代理拦截的写入才会收集依赖与触发。
  • 误区:代理深拷贝了原始对象;正解:代理转发引用,底层仍是同一原始对象。

追问

  • Q:为什么需要 toRaw? A:绕过代理做批量性能操作、传给不需要响应式的第三方库,避免代理开销。
  • Q:markRaw 用于什么场景? A:标记对象不被转为响应式代理,如大型不可变数据或类实例。

03.4.2.1-017 数组的响应式如何实现?

一句话结论

Vue 3 对数组通过 Proxy 拦截索引读写、length 变更与集合方法;读取元素收集依赖,修改索引/长度或调用变更方法后触发对应依赖更新。

概念解释

  • 索引赋值、length 修改被 set 拦截。
  • push/pop/splice 等变更方法包装后触发更新。
  • 遍历读取建立元素级依赖。

原理流程

  1. 数组被 reactive/ref 包装为代理。
  2. 读取索引/遍历 track 对应依赖。
  3. 索引/长度/方法变更 trigger 依赖并调度更新。

代码 / 示例

const list = ref<string[]>([]);
list.value.push("a");
list.value[1] = "b";
list.value.length = 0;

常见误区

  • 误区:Vue 3 数组下标修改不响应;正解:Proxy 可拦截索引写入,与 Vue 2 需重写方法的方案不同。
  • 误区:直接改数组内部对象属性一定触发列表更新;正解:对象为响应式代理时属性变更触发,浅包装场景需整体替换。

追问

  • Q:Vue 2 数组为什么要重写原型方法? A:defineProperty 无法拦截索引与方法变更,需覆盖变更方法通知更新。
  • Q:数组大列表更新如何减少开销? A:稳定 key、批量替换后整体触发,避免逐项触发渲染。

03.4.2.1-018 Vue 2 与 Vue 3 响应式有哪些版本边界?

一句话结论

Vue 2 基于 Object.defineProperty 递归劫持属性,需重写数组方法,新增属性需手动声明;Vue 3 基于 Proxy,覆盖新增/删除属性与集合类型。具体迁移与兼容行为以 Vue 3.x 官方文档为准,不确定项标注待确认。

概念解释

  • Vue 2:属性预定义 getter/setter,新增属性不响应。
  • Vue 3:Proxy 动态拦截,无需遍历预定义全部键。
  • 选项式 API 在 Vue 3 仍支持,组合式 API 为新增主线。

原理流程

  1. 对比拦截机制:defineProperty 逐属性 vs Proxy 整体代理。
  2. 评估数组、集合、新增属性支持差异。
  3. 按项目 Vue 版本核对 API 与行为。

代码 / 示例

Vue 2:
  Object.defineProperty 递归劫持
  数组方法重写;新增属性需 $set
Vue 3:
  Proxy 代理对象/数组/集合
  新增删除属性、索引变更自动响应

常见误区

  • 误区:Vue 3 完全废弃选项式 API;正解:选项式仍可用,组合式 API 是新增推荐方式。
  • 误区:两套响应式 API 行为可以直接互换;正解:ref/reactive 与 Vue 2 data/this.$set 模型不同,需按版本迁移。

追问

  • Q:如何确认项目 Vue 版本与响应式行为? A:查看 package.json 依赖版本与实际安装版本,对照官方升级指南确认。
  • Q:组合式 API 在哪些版本可用? A:Vue 3.x 内置,Vue 2.7 向后移植了部分组合式能力,具体支持范围待按版本文档确认。