一个用 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。对原始对象做了一层拦截:读属性时记录「谁在读」,写属性时通知「读过的人」。核心就这两件事,剩下的都是围绕它们做的簿记。

一次读写经过的路径
get 拦截返回属性值,同时记录当前正在运行的 effect
建立依赖把 effect 存进这个属性对应的依赖集合
set 拦截比较新旧值,不同则取出依赖集合
排队通知把 effect 放进调度队列,等微任务统一执行

这里有个全局变量,叫当前活跃的 effect。组件渲染、watch 回调、computed 求值,本质上都是在某个 effect 里执行。执行期间,任何被读到的响应式属性都会把这个 effect 记到自己的依赖集合里。执行结束,活跃 effect 出栈,依赖收集也就停了。

依赖关系是多对多的:一个 effect 可能读了很多属性,一个属性也可能被很多 effect 读。所以每个属性存一个集合,每个 effect 也反向记着自己依赖了谁,方便清理和停止。集合里存的是 effect 对象,不是回调函数本身;effect 被停止时会把自己从这些集合里摘掉,否则集合会越积越大。

写属性时会先比较新旧值。如果值没变(用 Object.is 判断),直接返回,不触发任何通知。这就是为什么「把同一个值再赋一遍」不会引发更新,也是为什么修改对象内部属性时,必须保证那个属性本身是被代理拦截到的。

嵌套对象不是一次性全部代理的。访问到某个属性、发现它的值是对象时,才把它包成 Proxy 再返回,这叫懒代理。好处是初始化大对象时不用递归遍历;代价是第一次访问某个深层属性时会有一次额外的包装开销。

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 的实现都有调整,官方也公布过内存占用方面的改进。这篇讲的是行为模型,具体到某一版源码里的数据结构,以你项目实际依赖的版本为准;拿不准的地方不要凭旧文章下结论。

今天就能动手的实验

  1. 写一个只有 reactive 和 effect 的小脚本,打印 effect 的执行次数;再改成解构取值,观察它不再触发。
  2. 用 let state = reactive(...),先改属性、再整体赋值,各试一次,记录页面和 effect 的反应;改用 ref 重复一遍。
  3. 写一个列表,在 watch 回调里读容器高度,先用默认配置,再改 flush: "post",对比两次输出。
  4. 用 toRefs 把对象拆成一组 ref,确认解构之后仍然能更新;再对比直接解构的结果。
  5. 拿一个几千条的对象数组,分别用 ref 和 shallowRef 整体替换,用 Performance 面板比较更新耗时。

小结

响应式追踪的是属性访问,不是变量。解构、展开、整体重新赋值都会把「绑定」变成「当时的快照」。
Proxy 在 get 时记录当前 effect,在 set 时把依赖排进队列。通知是批量的,在微任务里统一执行,所以更新不会立刻反映到 DOM。
computed 懒求值、靠脏标记缓存;watch 的 flush 决定它在 DOM 更新前还是后执行。这两个时机选错,就会出现「读到旧值」。
深层代理和深度监听都有成本。大块数据用 shallowRef、markRaw,把响应式留给真正需要追踪的部分。

下一篇讲JS 引擎内部。这一篇里的每一次属性访问、每一个被包起来的对象、每一个依赖集合,最终都要落到引擎的对象模型和内存管理上。为什么有的写法快、有的写法慢,为什么对象越建越多之后页面会变迟钝,要到引擎那一层才有答案。先看完框架怎么追踪变化,再看引擎怎么执行这些追踪,顺序正好。