Skip to content

Vue 3 基础:响应式原理、组件与组合式 API ​

本篇要点:能说清一次赋值为什么触发渲染、为什么有些赋值不触发,并在 ref、reactive、computed、watch、组件通信、组合式函数之间给出有理由的选择。 前置:会 HTML/CSS 与 ES2020 的模块、Promise、解构即可。这一章是整个类目的起点,《构建工具:Vite 8 与 Rolldown 工程配置》之后的构建、路由、状态、请求都建立在这里的响应式模型上。

为什么需要它 ​

2024 年 8 月,一个后台项目里出现过这样一段代码。页面上有两个组件渲染同一份用户数据:左边是头像卡片,右边是资料表单。

vue
<!-- 左边:解构了 props -->
<script setup lang="ts">
const { user } = defineProps<{ user: User }>()
</script>
<template><span>{{ user.name }}</span></template>

<!-- 右边:直接读 props -->
<script setup lang="ts">
const props = defineProps<{ user: User }>()
</script>
<template><span>{{ props.name }}</span></template>

预期输出:父组件把 user 换成另一个人之后,右边显示新名字,左边仍是旧名字,控制台无任何报错。

两个组件读的是同一个 props 对象,代码看起来只差一行解构。

这类问题排查起来很费时间,因为控制台不报错,console.log 打出来的值也是对的(解构那一刻确实拿到了正确的对象),只是之后再也没有跟着变。要解释它,得回答一个具体问题:Vue 是在哪一刻"知道"这个组件依赖了 user 的?答案不在数据上,在读取动作上——只有经过响应式代理(Proxy)的读取才会被登记,解构把值取出来存进了一个普通变量,之后的更新就再也找不到这个组件了。

截至 2026 年 11 月,Vue 3.5 起 defineProps 的解构已经改成编译期按属性访问生成,上面这个具体 bug 不再复现。但"读取路径决定追踪"这条规律没有变:把 reactive 对象的属性解构到普通变量、先把 ref 的 .value 取出来再存进普通变量、把对象浅拷贝一份再用,断的地方不一样,断的原因完全相同。记住规律,比记住哪一版修了哪个 bug 有用。

核心概念 ​

Proxy 与依赖收集 ​

响应式(reactivity)的意思是"读的时候记账,写的时候按账本通知"。Vue 3 用 Proxy 包住你的对象。Proxy 是 ES6 提供的元编程能力,可以拦截对目标对象的读取、赋值、删除等操作——注意它能拦截的是属性操作,不是变量赋值,这一点决定了后面 ref 为什么必须存在。

一次渲染的过程是这样的:组件渲染函数执行,读到 state.count,触发 get 陷阱,track() 把"当前正在执行的副作用(effect)"记进一张表;随后有人执行 state.count = 1,触发 set 陷阱,trigger() 从表里取出所有依赖这个 key 的 effect,交给调度器排队重跑。如图 1-1 所示。

图 1-1 一次读取记账、一次写入按账本通知

用图书馆打比方:谁借了哪本书登记在册,书有新版本了就通知所有借过这本书的人。没登记过的人当然收不到通知——解构赋值就是"从图书馆抄了个书名回家",你没留下借阅记录。

ref、reactive 与其边界 ​

reactive() 只接受对象(Object、Array、Map、Set),返回一个代理,适合放一组互相关联的字段。ref() 接受任意值,内部包成 { value } 对象,通过 get value / set value 实现追踪;之所以需要这层壳,是因为 JavaScript 拦不住对普通变量的赋值,只能拦属性访问。模板里 ref 自动解包,reactive 对象里的 ref 也会自动解包,但数组和 Map 里的 ref 不会。

两个反例值得记住。第一,const { count } = reactive({ count: 0 }) 拿到的 count 是普通数字,改它不会通知任何人;需要 toRefs() 或直接写 state.count。第二,let state = reactive({ rows: [] }) 之后写 state = reactive({ rows: await fetchPage() }),模板里那些已经捕获旧引用的地方(子组件 props、闭包、provide 出去的值)仍然指向旧代理;要整体替换,用 ref 持有整个对象,state.value = {...} 才能被追踪。

还有两个不常用但该知道的开关。shallowRef() 只追踪 .value 的整体替换,不深度代理内部对象,适合放第三方实例(ECharts 的 chart、地图对象、编辑器实例)——用 ref 包这些对象,Proxy 会逐层代理它们内部几百个属性,既慢又容易在实例内部报奇怪的错。markRaw() 则直接给对象盖上"永不复原"的标记,让它进 reactive 时不被代理,常用来标记那些不该被 Vue 观察的类实例和组件定义对象。

computed 与 watch 的分工 ​

computed 产出值:惰性求值、依赖不变就用缓存,依赖一变就标脏,下次被读时才重算。它必须是纯函数——不写 state、不发请求、不改 DOM。watch 产生副作用:发请求、写 localStorage、操作 DOM,能拿到新旧值,还能用 immediate、deep、flush: 'pre' | 'post' | 'sync' 控制时机。watchEffect 自动收集依赖,省事,代价是看代码不容易知道它依赖了什么。

反例:用 watch 去维护一个本该是派生值的状态——watch(price, () => total.value = price.value * qty.value)。只改 price 时正常,只改 qty 时 total 不动,于是再补一个 watcher。两份状态靠 watcher 同步,路径一多必然漏。凡是"能由别的状态算出来"的,都该用 computed。

组件通信的六种方式 ​

组件之间传数据的写法有六种,选错的代价通常要在重构时才显现。

方式方向适用场景注意
props / emits父 ↔ 子绝大多数常规传值emits 必须声明,否则同名原生事件会被触发两次
v-model(defineModel)双向表单控件、受控组件3.4 起 defineModel 是稳定 API,一个组件可挂多个 v-model
透传属性($attrs)父 → 子内部元素包装组件把 class、style、事件交给根元素配 inheritAttrs: false,位置由你决定
provide / inject跨层级向下主题、国际化、当前用户key 用 Symbol,必须给默认值或注入处校验
模板 ref + defineExpose父 → 子(命令式)focus()、open()、scrollTo()只在必要时开,暴露越多耦合越紧
Pinia任意跨页面共享、需要持久化见《状态管理:Pinia 3 模块化与持久化》

反例:把响应式对象直接 provide 下去,子孙组件解构使用,父级换了整个对象后子孙不更新。跨层级传值时,传 ref 比传对象值更稳——引用不变,值在里面换。

生命周期与组合式函数 ​

<script setup> 里写的同步代码相当于 beforeCreate + created,之后用 onMounted、onUpdated、onUnmounted、onErrorCaptured 注册钩子。钩子必须在 setup 同步执行期注册;在 await 之后注册会得到 "onMounted is called when there is no active component instance" 的警告。服务端渲染时没有 onMounted,涉及浏览器 API 的初始化要放到钩子里。

组合式函数(composable)是把"带状态的逻辑"抽出来复用的函数,约定 use 开头:参数收 ref 或 getter 以保持响应性,返回值给 ref,内部注册的副作用(事件监听、定时器、IntersectionObserver)必须自己清理。这是新手最容易漏的一条:抽了函数、没抽清理,组件切走十次,监听器就叠十份。

动手实践 ​

四步,每步都能自己验证。

第一步,建项目。 Node 20 以上,执行 pnpm create vue@latest vue-core,只勾 TypeScript,其余不选;cd vue-core && pnpm i && pnpm dev。预期输出:终端打印 VITE v8.x ready in 3xx ms(截至 2026 年 11 月,create-vue 模板已切到 Vite 8 与 Rolldown)和本地地址 http://localhost:5173/。

第二步,手写一个 30 行的迷你响应式。 目的不是复刻 Vue,是把 track / trigger 那张表变成自己写过的代码。新建 src/reactivity/mini.ts:

ts
// src/reactivity/mini.ts —— 只用来理解模型,不是 Vue 源码
type Effect = () => void
const targetMap = new WeakMap<object, Map<string, Set<Effect>>>()
let activeEffect: Effect | null = null

export function effect(fn: Effect) {
  activeEffect = fn
  fn()                    // 先跑一次,读取时顺手记账
  activeEffect = null
}

function track(target: object, key: string) {
  if (!activeEffect) return             // 不在任何 effect 里,不记
  let deps = targetMap.get(target)
  if (!deps) targetMap.set(target, (deps = new Map()))
  let dep = deps.get(key)
  if (!dep) deps.set(key, (dep = new Set()))
  dep.add(activeEffect)
}

function trigger(target: object, key: string) {
  targetMap.get(target)?.get(key)?.forEach((fn) => fn())
}

export function reactive<T extends object>(target: T): T {
  return new Proxy(target, {
    get(obj, key, receiver) {
      track(obj, key as string)
      return Reflect.get(obj, key, receiver)
    },
    set(obj, key, value, receiver) {
      const ok = Reflect.set(obj, key, value, receiver)
      trigger(obj, key as string)
      return ok
    },
  })
}

运行结果:pnpm vue-tsc --noEmit 通过,模块导出 effect 与 reactive 两个函数,行为由下一步验证。

第三步,验证记账。 在 src/main.ts 顶部临时加一段(验证完删掉,别留在项目里):

ts
import { effect, reactive } from './reactivity/mini'

const state = reactive({ count: 0, tip: 'hello' })
effect(() => console.log('render:', state.count))
state.count++
state.count++
state.tip = 'changed'   // 没有任何 effect 读过 tip,不触发

// 控制台:
// render: 0
// render: 1
// render: 2

预期输出:render: 打印三次,值依次为 0、1、2;tip 那次赋值一行都不输出,因为 effect 只读过 count。

把 state.tip = 'changed' 换成 state.count = 99,会再多出一行 render: 99。写完这一段,再看 Vue 的 track / trigger 源码注释就不会觉得隔。真实实现多了数组方法与迭代器的单独拦截、ref 的 value 访问器、依赖去重和调度队列,但主干就是这么几步。

第四步,抽一个能自己收尾的组合式函数。 新建 src/composables/useTicker.ts:

ts
import { onUnmounted, readonly, ref } from 'vue'

export function useTicker(ms = 1000) {
  const ticks = ref(0)
  const id = setInterval(() => { ticks.value++ }, ms)
  onUnmounted(() => clearInterval(id))   // 谁创建谁清理
  return { ticks: readonly(ticks) }
}

预期输出:在组件里 每秒加一;用 v-if 把组件卸载后,performance 面板里计时器数量回到 0,控制台不再有新数字。把 onUnmounted 那行注释掉再试一次,计时器会一直跑——这就是"抽了逻辑没抽清理"的样子。

常见误解 ​

"reactive 是深度的,怎么改都能追踪。" 深度只对"通过代理读写"有效。解构、浅拷贝、JSON.parse(JSON.stringify())、把 .value 存进普通变量,这几条路都绕开了 get 陷阱,深度与否无关。判断标准只有一条:这次读取有没有经过代理。

"computed 和 watch 的区别就是有没有缓存。" 缓存只是现象。根本区别是 computed 的返回值是数据、watch 的回调是副作用。把请求写进 computed,看起来"数据变了就自动拉",实际上请求的发起时机被渲染调度决定,重复渲染可能发重复请求,也没法取消——这类问题在《请求层:HTTP 封装、缓存与错误处理》用请求层统一解决。

"生命周期钩子写完就完了,清理是框架的事。" 框架只管它自己创建的东西。addEventListener、setInterval、new WebSocket、第三方图表实例,都是你创建的外部资源。抽成组合式函数后,清理责任跟着函数走,这恰恰是组合式函数要处理的第一件事,而不是最后补的。

小结 ​

  • 响应式的本质是"读取时记账、写入时通知",记账的载体是 Proxy 的 get/set 陷阱,绕开读取就绕开了追踪。
  • reactive 适合一组字段,ref 适合需要整体替换的值;解构会断链,需要 toRefs 或直接访问属性。
  • computed 算值、watch 做副作用;能用前者算出来的状态,不要用后者同步。
  • 组件通信按"距离与方向"选:父子用 props/emits 与 v-model,跨层级用 provide/inject,全局用 Pinia。
  • 组合式函数的完整交付包含三件事:use 命名、响应式参数与返回、副作用的创建与清理。

相关主题 ​

这一章的组合式函数只在自己项目里用,参数写错顶多自己改;一旦要被别的业务组引用,(options: any) 这种签名就会把错误推到运行时。《TypeScript 与 Vue:类型安全与类型测试》讲 TypeScript 与 Vue:类型安全与类型测试,把 props、emits、defineModel 和组合式函数的入参出参写成会报错的契约,并让 vue-tsc 在合并前拦住它们。