一个用 Vue 3 写的表单页,接口返回用户信息后赋给一个 reactive 对象,页面正常显示。后来为了方便,在 setup 里写了一行解构:
const state = reactive({ name: "", age: 0 });
// 解构出来用
const { name } = state;
之后无论怎么改 state.name,页面上那个 name 都不动了。把解构删掉,改成每次直接用 state.name,又恢复正常。
另一类更隐蔽:
let state = reactive({ count: 0 });
// 某个回调里「重置」
state = { count: 1 };
赋值那一刻页面没反应,之后这个 state 也彻底失去了响应性。看起来都是「改了个变量」,为什么第一个还能追踪,第二个就断了?
这篇就从这两个现象出发,讲清 Vue 3 的响应式到底在追踪什么、什么时候通知、通知之后为什么不是立刻更新 DOM。它和上一篇 React 的显式调度是两条完全不同的路,理解差异之后,很多「为什么这个写法突然不生效」的问题就不用死记了。
先分清「值」和「绑定」
Vue 的响应式追踪的是属性访问,不是变量本身。当你写 const { name } = state 时,发生的是:读取 state.name 一次,把读到的那份值(一个字符串)赋给一个新的局部常量。从此 name 就是一个普通字符串,它不知道自己来自哪里,也不会再和 state 建立任何联系。
const state = reactive({ name: "张三" });
const { name } = state; // 读取一次,得到一个字符串
state.name = "李四"; // 触发的是 state.name 的 setter
console.log(name); // 还是「张三」
这就是「解构丢响应性」的全部原因,不是什么框架 bug。它和普通 JavaScript 的取值行为完全一致,只是当你习惯了 state.x 的自动追踪后,会误以为解构也保留了那根线。
同样地,把整个 state 变量重新赋值,等于把一个普通对象换给了这个变量。原来的 Proxy 还在,模板里如果还引用着旧的 Proxy,就会继续追踪旧对象;如果模板读的是这个变量本身,下次渲染会读到普通对象,从此再没有 setter 被触发。
验证这两个结论不需要猜。写一个最小脚本,用 effect 手动跑一次依赖收集:
import { reactive, effect } from "@vue/reactivity";
const state = reactive({ count: 0 });
effect(() => {
console.log("count 变了", state.count);
});
state.count = 1; // 会再打印一次
把 state.count 改成先解构再用,第二次就不会打印。把 state 换成普通对象,也不会打印。通过这个最小实验,现象和机制就对齐了:追踪绑在属性访问上,值一旦被取出来,线就断了。
Proxy 在做什么
Vue 3 的 reactive 返回的是一个 Proxy。对原始对象做了一层拦截:读属性时记录「谁在读」,写属性时通知「读过的人」。核心就这两件事,剩下的都是围绕它们做的簿记。
这里有个全局变量,叫当前活跃的 effect。组件渲染、watch 回调、computed 求值,本质上都是在某个 effect 里执行。执行期间,任何被读到的响应式属性都会把这个 effect 记到自己的依赖集合里。执行结束,活跃 effect 出栈,依赖收集也就停了。
依赖关系是多对多的:一个 effect 可能读了很多属性,一个属性也可能被很多 effect 读。所以每个属性存一个集合,每个 effect 也反向记着自己依赖了谁,方便清理和停止。集合里存的是 effect 对象,不是回调函数本身;effect 被停止时会把自己从这些集合里摘掉,否则集合会越积越大。
写属性时会先比较新旧值。如果值没变(用 Object.is 判断),直接返回,不触发任何通知。这就是为什么「把同一个值再赋一遍」不会引发更新,也是为什么修改对象内部属性时,必须保证那个属性本身是被代理拦截到的。
trigger 之后为什么不立刻更新
通知不是同步执行 effect,而是把 effect 塞进一个队列,等当前调用栈清空后在微任务里统一处理。原因很实际:一次操作可能同时改动多个属性,每个属性都直接执行 effect,就会重复渲染好几次。
const state = reactive({ a: 1, b: 2, c: 3 });
watchEffect(() => console.log(state.a, state.b, state.c));
state.a = 10;
state.b = 20;
state.c = 30;
// 三个属性都变了,但 effect 只执行一次
队列会去重:同一个 effect 在一个批次里只排一次。执行顺序也有讲究,组件更新的 effect 按组件树的层级排列,父组件先于子组件,避免子组件先更新、父组件又把它整个替换掉这种白干活。如果某个 effect 在执行过程中又改了别的响应式属性,新产生的更新会追加到当前队列,等这一轮清完再处理,不会递归爆栈。
队列清空发生在微任务里。所以下面这段代码里,第二行读到的还是旧 DOM:
state.count++;
console.log(el.textContent); // 旧内容
await nextTick();
console.log(el.textContent); // 新内容
nextTick 返回的 Promise 在队列清空后 resolve,也可以直接传回调。它和 setTimeout 不一样,不需要等下一轮宏任务,属于微任务级别的等待。
这也解释了 watch 的 flush 选项为什么重要。默认的 'pre' 表示回调在组件更新之前执行,适合在数据变化后、DOM 更新前做计算;'post' 表示在组件更新之后执行,能读到新 DOM;'sync' 是同步执行,一般只在需要精确捕获每一次变化时用,代价是失去批处理。
watch(
() => state.list.length,
() => {
console.log(listEl.value.scrollHeight); // 想读更新后的高度
},
{ flush: "post" }
);
computed 为什么能缓存
computed 内部也是一个 effect,但它不立即执行,而是懒执行:第一次读 .value 时才跑一次求值,跑的过程中收集依赖。之后依赖再变,它不马上重算,只把一个「脏」标记置上;等到有人再次读 .value,才重新求值。
这带来一个很实用的性质:如果一个 computed 依赖的上游变了,但页面上暂时没用到它,就不会白算。反过来,如果它被很多地方读,就算一次,大家共用结果。
要注意的是,computed 里不该有副作用。它可能因为依赖变化被多次求值,也可能因为没人读而一直不执行。把发请求、改状态这类动作放进去,执行次数完全不受你控制。要副作用就用 watch 或者 watchEffect,它们的语义是「变化时执行」,而不是「求值时计算」。
另一个常见困惑是「computed 不更新」。先检查它依赖的东西是不是响应式的:
const raw = { count: 0 }; // 普通对象
const doubled = computed(() => raw.count * 2);
raw.count = 1; // 不会通知任何 effect
console.log(doubled.value); // 还是 0
const state = reactive({ count: 0 });
const doubled2 = computed(() => state.count * 2); // 正常追踪
如果依赖的是一个 ref,记得在 JS 里读 .value;在模板顶层可以直接写名字,Vue 会自动解包。这个差异是新手最常踩的坑之一:同一个变量,在脚本里要写 count.value,在模板里写 count,两种写法混用就会得到 undefined 或者一串对象。
watchEffect 和 watch 的差别也在这里。watchEffect 不写源,运行时自动把读到的属性都收进依赖集合,写起来省事,但很难一眼看出它到底依赖了什么;watch 要求显式写出源,依赖关系清楚,代价是漏写就不触发。需要长期维护的组件逻辑,倾向后者;一次性的调试或简单联动,前者更顺手。
还有一个容易忽略的细节:computed 被读取时,如果它自己没有被任何 effect 依赖,这次求值不会让任何人更新。只有当模板或者别的 watch 读过它,它的变化才有意义。这也解释了为什么某些「只在调试面板里看一眼」的 computed,改了之后页面毫无反应。
ref、reactive 和自动解包
reactive 只能代理对象,原始类型不行,所以有了 ref:用一个带 .value 的包装对象来装数字、字符串、布尔值。它的 getter 里做依赖收集,setter 里做通知,机制和 Proxy 那套一样,只是拦截点换成了单个属性。
两者最实际的区别在于「整体替换」:
reactive
适合一个结构稳定的对象。整体替换会断掉追踪,要重置就逐字段赋值,或者用 Object.assign 走过 setter。
ref
适合会整体替换的值或对象。赋值走 .value 的 setter,天然支持「换一个新对象」,模板里还能自动解包。
Object.assign(state, newData) 之所以能保持响应性,是因为它的每个赋值都经过了 Proxy 的 set 拦截;而 state = newData 换的是变量,根本没碰到 Proxy。
模板里的自动解包只发生在顶层:从 setup 返回的 ref,在模板里可以直接写名字;如果 ref 被塞进一个普通对象里,通过 obj.someRef 访问,就需要 .value。如果塞进的是 reactive 对象,则又会自动解包。这条规则没有一个统一的直觉,遇到读不到值时,先确认它处在哪一层。
组件更新只是其中一种 effect
组件首次渲染时,render 函数本身就在一个 effect 里执行。它读到的每个响应式属性都会被记下来,和组件实例建立关系。之后任何一处依赖变化,都会把这个组件的更新任务排进队列。
这意味着「模板里没用到的属性,改了不会触发渲染」。反过来说,在 setup 里读了一个属性、又在模板里用了它,即使这个读取发生在组件之外,也照样算依赖,因为读取时活跃的 effect 就是这个组件的渲染 effect。
组件卸载时,它对应的 effect 会被停止,依赖集合里也会清理掉相关记录。如果手动创建了 watch 或 effect 却没有停止,组件没了它还在跑,就会造成内存和性能问题。Vue 提供 effectScope 来批量管理这类副作用,组件内部的 watch 会自动绑定到组件的作用域。
服务端渲染时情况又不一样:没有浏览器的渲染 effect,也就不会因为属性读取而建立组件依赖。所以同一份响应式代码在服务端不会触发组件更新,这本身没问题;但如果你在服务端用模块级变量存响应式对象,它会被所有请求共享,这一点和上一篇讲的模块状态问题完全一样。
顺带说一个实际项目里常用的取舍。shallowRef 只追踪 .value 这一层,内部对象怎么改都不管:
const list = shallowRef([1, 2, 3]);
list.value.push(4); // 不触发更新
list.value = [...list.value, 4]; // 触发
// 也可以手动通知:triggerRef(list)
它的价值在于「大对象整体替换」这种用法:列表数据从接口整份回来,直接换 .value,既触发了更新,又省掉了深层代理的开销。代价是任何原地修改都不会被感知,团队里必须约定清楚这块数据是「只整体替换」的,否则又会回到「改了没反应」的老问题。
现象、机制、怎么自己验证
| 现象 | 真实机制 | 怎么验证 |
|---|---|---|
| 解构出来的值不再更新 | 解构是一次读取,拿到的是当时的值,不是绑定 | 用 effect 打印依赖触发次数;改用 toRefs 或直接访问 state.x |
reactive 变量整体重新赋值后失去响应 |
换的是变量,新的普通对象没有 Proxy,旧依赖也不会被通知 | 赋值前后打印 state 的构造器与行为;用 Object.assign 或改成 ref 对比 |
watch 回调里读 DOM 拿到旧高度 |
默认 flush: 'pre',回调在组件更新之前执行 |
改成 flush: 'post' 或在回调里 await nextTick(),对比数值 |
computed 依赖变了却不重算 |
依赖的不是响应式数据,或者读取时不在任何 effect 里 | 在 computed 里打印,确认触发次数;把源换成 reactive/ref |
修改 Map/Set 有时不触发更新 |
集合类型走专门的拦截逻辑,拿到原始对象再改就绕过了 Proxy | 用 reactive(new Map()) 操作;再用 toRaw 拿到原对象改一次,对比是否触发 |
| 大对象或大列表一改就明显卡顿 | 深层属性被逐个代理,读写都多一层拦截开销 | 用 ref 与 shallowRef 分别测一次整体替换的耗时;用 markRaw 排除纯展示数据 |
模板里写 count 能取到值,脚本里写 count 是对象 |
ref 只在模板顶层自动解包,普通 JS 作用域需要 .value |
在模板和 setup 里各打印一次同一个 ref,观察输出类型 |
边界与代价
Proxy 不是免费的。 每一次属性读写都要过一层拦截,深层对象的每次访问都可能触发懒代理的包装。对一个普通的表单对象,这点开销可以忽略;对一个上万条记录、每条几十个字段的表格,差别就出来了。这种数据的正确做法通常是整体替换加 shallowRef,而不是指望每个字段都响应式。
深度追踪是有成本的。 watch 开启 deep 后,为了建立依赖,会递归遍历整个对象。对象越大、层级越深,首次遍历和后续触发都越贵。多数时候你要的只是「某个字段变了通知我」,那就用 getter 精确指定,而不是一上来就 deep。
响应式不等于不可变。 用 toRaw 拿到原始对象后修改,不会触发任何更新。这在和第三方库交互时很方便(比如图表库自己维护数据),但也很容易造成「数据改了、页面没变」的错觉。绕过了代理,就别指望框架知道。
冻结对象会退化。 传一个 Object.freeze 过的对象给 reactive,开发环境会有警告,运行时也无法正常追踪。别把冻结当成数据保护手段用在响应式数据上。
解构和展开都会丢绑定。 不光是解构,{ ...state } 展开也是逐个读取,得到的是一份普通对象。想保留响应性用 toRefs,或者就别拆,直接带着对象走。团队里最好统一一种写法,否则后人很容易在某个分支里加一行解构,把问题埋进去。
副作用要有归属。 watch、effect、定时器、事件监听,都要能在组件卸载时停掉。Vue 的组件作用域帮你管住组件内的那部分,手动在模块级创建的就不会。项目里常见的「切页面越切越卡」,往往是这些没被回收的 effect 在累积。
版本细节不要当成永久结论。 Vue 3.4 和 3.5 对响应式内部做过几轮重写,依赖存储结构、computed 的实现都有调整,官方也公布过内存占用方面的改进。这篇讲的是行为模型,具体到某一版源码里的数据结构,以你项目实际依赖的版本为准;拿不准的地方不要凭旧文章下结论。
今天就能动手的实验
- 写一个只有
reactive和effect的小脚本,打印 effect 的执行次数;再改成解构取值,观察它不再触发。 - 用
let state = reactive(...),先改属性、再整体赋值,各试一次,记录页面和effect的反应;改用ref重复一遍。 - 写一个列表,在
watch回调里读容器高度,先用默认配置,再改flush: "post",对比两次输出。 - 用
toRefs把对象拆成一组 ref,确认解构之后仍然能更新;再对比直接解构的结果。 - 拿一个几千条的对象数组,分别用
ref和shallowRef整体替换,用 Performance 面板比较更新耗时。
小结
computed 懒求值、靠脏标记缓存;watch 的 flush 决定它在 DOM 更新前还是后执行。这两个时机选错,就会出现「读到旧值」。shallowRef、markRaw,把响应式留给真正需要追踪的部分。下一篇讲JS 引擎内部。这一篇里的每一次属性访问、每一个被包起来的对象、每一个依赖集合,最终都要落到引擎的对象模型和内存管理上。为什么有的写法快、有的写法慢,为什么对象越建越多之后页面会变迟钝,要到引擎那一层才有答案。先看完框架怎么追踪变化,再看引擎怎么执行这些追踪,顺序正好。