Vue 3 的響應式系統是一次徹底的架構重寫。從 Vue 2 的 Object.defineProperty 到 Vue 3 的 Proxy,不僅是 API 的變化,更是響應式模型從"屬性劫持"到"對象代理"的範式轉變。Vue 3.6 在此基礎上進一步優化了 effect 調度和內存管理。本文從源碼層面剖析 ref 和 reactive 的實現差異。
響應式系統的核心模型
Vue 的響應式系統由三個核心部分組成:
- 響應式數據:通過 Proxy 攔截數據的讀寫操作
- 依賴收集(track):在數據被讀取時,記錄當前正在執行的 effect
- 觸發更新(trigger):在數據被修改時,通知所有依賴此數據的 effect 重新執行
effect 執行 → 讀取響應式數據 → track 收集依賴 → 數據變更 → trigger 通知 effect → effect 重新執行
這個模型的關鍵在於:effect 執行期間讀取的所有響應式數據,都會與該 effect 建立關聯。當任何關聯數據變更時,effect 就會被重新執行。
reactive 的實現
reactive 的核心是 new Proxy(target, handlers),攔截 get、set、has、deleteProperty 等操作。
// Vue 3.6 源碼簡化版
const reactiveMap = new WeakMap<object, any>()
function reactive<T extends object>(target: T): T {
// 已經是響應式對象,直接返回
if (target.__v_isReactive) {
return target
}
// 緩存檢查:同一個對象只代理一次
const existingProxy = reactiveMap.get(target)
if (existingProxy) {
return existingProxy
}
const proxy = new Proxy(target, {
get(target, key, receiver) {
if (key === '__v_isReactive') return true
// 數組特殊處理
const targetIsArray = Array.isArray(target)
if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
return Reflect.get(arrayInstrumentations, key, receiver)
}
const res = Reflect.get(target, key, receiver)
// 內置 Symbol 不做依賴收集
if (isSymbol(key) && builtInSymbols.has(key)) {
return res
}
// 依賴收集
track(target, key)
// 嵌套對象延遲響應化(lazy reactive)
if (isObject(res)) {
return reactive(res)
}
return res
},
set(target, key, value, receiver) {
let oldValue = (target as any)[key]
const hadKey = Array.isArray(target) && isIntegerKey(key)
? Number(key) < target.length
: hasOwn(target, key)
const result = Reflect.set(target, key, value, receiver)
// 避免 prototype 鏈上的 set 觸發重複更新
if (target === toRaw(receiver)) {
if (!hadKey) {
// 新增屬性 → ADD
trigger(target, 'add', key, value)
} else if (hasChanged(value, oldValue)) {
// 修改屬性 → SET
trigger(target, 'set', key, value, oldValue)
}
}
return result
},
deleteProperty(target, key) {
const hadKey = hasOwn(target, key)
const oldValue = (target as any)[key]
const result = Reflect.deleteProperty(target, key)
if (result && hadKey) {
trigger(target, 'delete', key, undefined, oldValue)
}
return result
},
has(target, key) {
const result = Reflect.has(target, key)
if (!isSymbol(key) || !builtInSymbols.has(key)) {
track(target, key)
}
return result
},
ownKeys(target) {
track(target, Array.isArray(target) ? 'length' : ITERATE_KEY)
return Reflect.ownKeys(target)
},
})
reactiveMap.set(target, proxy)
return proxy
}
幾個關鍵設計決策值得注意:
延遲響應化:嵌套對象在首次被讀取時才調用 reactive(),而不是在創建時就遞歸處理整個對象樹。這避免了初始化時的性能開銷,也意味着未被訪問的嵌套對象不會創建 Proxy。
緩存機制:reactiveMap 確保同一個原始對象只創建一個 Proxy。多次調用 reactive(obj) 返回的是同一個代理。
數組特殊處理:Vue 3.6 對數組方法做了 instrumentation,確保 includes、indexOf、push、pop 等方法能正確觸發依賴收集和更新。
ref 的實現
ref 的存在是爲了解決一個根本問題:Proxy 無法代理原始值(string、number、boolean)。Proxy 的 target 必須是對象,對原始值調用 new Proxy(42, ...) 會拋出 TypeError。
// Vue 3.6 源碼簡化版
class RefImpl<T> {
private _value: T
private _rawValue: T
public dep: Dep = new Dep()
public readonly __v_isRef = true
constructor(value: T, public readonly __v_isShallow: boolean) {
this._rawValue = this.__v_isShallow ? value : toRaw(value)
// 對象類型會被 reactive 包裝
this._value = this.__v_isShallow ? value : toReactive(value)
}
get value() {
// 依賴收集
this.dep.track()
return this._value
}
set value(newVal) {
const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal)
const rawNewVal = useDirectValue ? newVal : toRaw(newVal)
if (hasChanged(rawNewVal, this._rawValue)) {
this._rawValue = rawNewVal
this._value = useDirectValue ? newVal : toReactive(newVal)
// 觸發更新
this.dep.trigger()
}
}
}
function ref<T>(value: T): Ref<T> {
return new RefImpl(value, false)
}
// toReactive: 對象類型用 reactive 包裝,原始值直接返回
function toReactive(value: T): T {
return isObject(value) ? reactive(value) : value
}
這就是 ref 需要 .value 的根本原因:需要一個載體對象來通過 getter/setter 攔截讀寫操作。.value 是這個載體上的屬性訪問器。
ref 與 reactive 的核心差異
| 維度 | reactive | ref |
|---|---|---|
| 支持的數據類型 | 僅對象 | 對象 + 原始值 |
| 代理機制 | Proxy 攔截整個對象 | getter/setter 攔截 .value |
| 嵌套響應化 | 自動遞歸(lazy) | 原始值不遞歸,對象委託給 reactive |
| 依賴存儲 | target → key → dep 映射 | ref 實例上的單一 dep |
| 訪問方式 | 直接訪問屬性 state.count | 需要 .value |
| 模板自動解包 | 不需要 | 自動解包(編譯器處理) |
| 替換整個對象 | 失效(Proxy 綁定在原對象上) | 可以(替換 _value) |
最後一點經常是 bug 來源:
// reactive 的陷阱
const state = reactive({ count: 0 })
const newState = reactive({ count: 1 })
state = newState // ❌ TypeError: Assignment to constant variable
// 即使不聲明爲 const,替換引用也會導致依賴追蹤斷裂
// ref 沒有這個問題
const state = ref({ count: 0 })
state.value = { count: 1 } // ✅ 正常工作,舊依賴會被清理
依賴收集(track)的完整流程
Vue 3.6 重構了依賴收集的數據結構,從 WeakMap 嵌套改爲更扁平的結構:
// Vue 3.6 簡化版依賴管理
// 當前正在執行的 effect
let activeEffect: ReactiveEffect | undefined
// 依賴映射:target → key → dep
const targetMap = new WeakMap<object, Map<PropertyKey, Dep>>()
function track(target: object, key: PropertyKey) {
if (!activeEffect) return
let depsMap = targetMap.get(target)
if (!depsMap) {
targetMap.set(target, (depsMap = new Map()))
}
let dep = depsMap.get(key)
if (!dep) {
depsMap.set(key, (dep = new Dep()))
}
dep.track()
}
// Dep 類:管理一組 effect
class Dep {
private effects = new LinkedSet<ReactiveEffect>()
track() {
if (activeEffect) {
this.effects.add(activeEffect)
// effect 也記錄自己被哪些 dep 收集了(用於清理)
activeEffect.deps.push(this)
}
}
trigger() {
// 複製一份,避免遍歷時新增導致無限循環
const effects = [...this.effects]
for (const effect of effects) {
// 避免遞歸調用自己
if (effect !== activeEffect) {
effect.trigger()
}
}
}
}
track 在 effect 執行期間被調用,將當前 activeEffect 與被讀取的屬性關聯起來。關鍵在於 activeEffect 的設置時機——它由 effect 函數管理:
class ReactiveEffect {
private fn: () => void
public scheduler?: (job: () => void) => void
public deps: Dep[] = []
private active = true
constructor(fn: () => void, scheduler?: (job: () => void) => void) {
this.fn = fn
this.scheduler = scheduler
}
run() {
// 清理舊依賴(解決分支切換問題)
if (!this.active) {
return this.fn()
}
const prevEffect = activeEffect
activeEffect = this
cleanupEffect(this)
try {
return this.fn()
} finally {
activeEffect = prevEffect
}
}
trigger() {
if (this.scheduler) {
// 有調度器時交給調度器決定何時執行
this.scheduler(() => this.run())
} else {
this.run()
}
}
}
function effect(fn: () => void, options?: { scheduler?: (job: () => void) => void }) {
const _effect = new ReactiveEffect(fn, options?.scheduler)
_effect.run()
return _effect
}
cleanupEffect 是一個關鍵步驟:每次 effect 重新執行前,先清除所有舊的依賴關係。這解決了分支切換問題——當條件分支改變時,之前分支中收集的依賴應該被清理。
function cleanupEffect(effect: ReactiveEffect) {
const { deps } = effect
for (let i = 0; i < deps.length; i++) {
deps[i].effects.delete(effect)
}
deps.length = 0
}
觸發更新(trigger)的完整流程
function trigger(
target: object,
type: 'set' | 'add' | 'delete',
key: PropertyKey,
newValue?: unknown,
oldValue?: unknown,
) {
const depsMap = targetMap.get(target)
if (!depsMap) return
const effects: Dep[] = []
// SET 操作:直接觸發 key 對應的 dep
if (type === 'set') {
const dep = depsMap.get(key)
if (dep) effects.push(dep)
}
// ADD 操作:觸發 key 的 dep + ITERATE_KEY 的 dep
if (type === 'add') {
const dep = depsMap.get(key)
if (dep) effects.push(dep)
const iterateDep = depsMap.get(ITERATE_KEY)
if (iterateDep) effects.push(iterateDep)
// 數組添加元素時,length 也要觸發
if (Array.isArray(target)) {
const lengthDep = depsMap.get('length')
if (lengthDep) effects.push(lengthDep)
}
}
// DELETE 操作:類似 ADD
if (type === 'delete') {
const dep = depsMap.get(key)
if (dep) effects.push(dep)
const iterateDep = depsMap.get(ITERATE_KEY)
if (iterateDep) effects.push(iterateDep)
}
// 執行所有相關 effect
for (const dep of effects) {
dep.trigger()
}
}
effect 調度器與批處理
Vue 的更新不是同步的。當一個事件處理函數中修改了多個響應式狀態,Vue 會將所有更新批量處理,只觸發一次組件重新渲染。這個機制通過 調度器(scheduler)和微任務隊列實現。
// 批處理隊列
const queue = new Set<ReactiveEffect>()
let isFlushing = false
const resolvedPromise = Promise.resolve()
function queueJob(effect: ReactiveEffect) {
queue.add(effect)
if (!isFlushing) {
isFlushing = true
resolvedPromise.then(flushJobs)
}
}
function flushJobs() {
try {
for (const effect of queue) {
effect.run()
}
} finally {
queue.clear()
isFlushing = false
}
}
// 組件的 effect 使用調度器
function setupEffect(instance: ComponentInternalInstance) {
const update = effect(() => {
// 渲染組件
instance.render()
}, {
scheduler: (job) => queueJob(job), // 使用調度器而非立即執行
})
}
批處理的效果:
const state = reactive({ count: 0, name: 'Vue' })
effect(() => {
console.log(`count: ${state.count}, name: ${state.name}`)
}, {
scheduler: (job) => queueJob(job),
})
// 批量修改
state.count = 1 // 入隊
state.name = 'Vue 3.6' // 入隊
state.count = 2 // Set 去重,同一個 effect 只入隊一次
// 微任務執行時,effect 只執行一次
// 輸出: count: 2, name: Vue 3.6
Vue 3.6 的改進在於 queue 從數組改爲 Set,天然去重,避免了同一 effect 被多次入隊的問題。此外,3.6 引入了 effect 優先級機制,確保組件更新 effect 在 computed effect 之前執行。
shallowRef 與 shallowReactive
function shallowRef<T>(value: T): Ref<T> {
return new RefImpl(value, true) // __v_isShallow = true
}
function shallowReactive<T extends object>(target: T): T {
return new Proxy(target, shallowReactiveHandlers)
}
// shallowReactive 的 handler
const shallowReactiveHandlers = {
get(target, key, receiver) {
if (key === '__v_isReactive') return true
track(target, key)
return Reflect.get(target, key, receiver)
// 注意:不調用 reactive(res),嵌套對象保持原始狀態
},
set(target, key, value, receiver) {
const oldValue = target[key]
const result = Reflect.set(target, key, value, receiver)
if (hasChanged(value, oldValue)) {
trigger(target, 'set', key, value, oldValue)
}
return result
},
}
使用場景:
import { shallowRef, triggerRef } from 'vue'
// 大列表數據:只關心整體替換,不關心內部屬性變化
const list = shallowRef<Item[]>([])
// 替換整個列表 → 觸發更新
list.value = fetchNewList()
// 修改內部屬性 → 不觸發更新
list.value[0].name = 'new name' // ❌ 不響應
// 手動觸發
list.value[0].name = 'new name'
triggerRef(list) // ✅ 手動通知更新
手寫簡化版響應式系統
將上述概念整合爲一個可運行的簡化版:
// ===== 簡化版響應式系統 =====
let activeEffect: (() => void) | null = null
const targetMap = new WeakMap<object, Map<PropertyKey, Set<() => void>>>()
function track(target: object, key: PropertyKey) {
if (!activeEffect) return
let depsMap = targetMap.get(target)
if (!depsMap) targetMap.set(target, (depsMap = new Map()))
let dep = depsMap.get(key)
if (!dep) depsMap.set(key, (dep = new Set()))
dep.add(activeEffect)
}
function trigger(target: object, key: PropertyKey) {
const depsMap = targetMap.get(target)
if (!depsMap) return
const dep = depsMap.get(key)
if (dep) {
for (const effect of [...dep]) {
if (effect !== activeEffect) effect()
}
}
}
function reactive<T extends object>(target: T): T {
return new Proxy(target, {
get(target, key, receiver) {
if (key === '__isReactive') return true
const result = Reflect.get(target, key, receiver)
track(target, key)
if (result && typeof result === 'object') {
return reactive(result)
}
return result
},
set(target, key, value, receiver) {
const oldValue = (target as any)[key]
const result = Reflect.set(target, key, value, receiver)
if (oldValue !== value) {
trigger(target, key)
}
return result
},
})
}
function ref<T>(value: T) {
const wrapper = {
get value() {
track(wrapper, 'value')
return value
},
set value(newVal: T) {
if (newVal !== value) {
value = newVal
trigger(wrapper, 'value')
}
},
}
return wrapper
}
function effect(fn: () => void) {
const run = () => {
activeEffect = run
try {
fn()
} finally {
activeEffect = null
}
}
run()
}
// ===== 使用示例 =====
const state = reactive({ count: 0, name: 'Vue' })
const double = ref(0)
effect(() => {
double.value = state.count * 2
console.log(`count: ${state.count}, double: ${double.value}`)
})
// 輸出: count: 0, double: 0
state.count = 5
// 輸出: count: 5, double: 10
state.count = 10
// 輸出: count: 10, double: 20
性能對比與使用場景
在 10000 條數據的列表更新場景下(Vue 3.6 vs Vue 2.7):
| 指標 | Vue 2.7 | Vue 3.6 |
|---|---|---|
| 初始化時間 | 120ms | 45ms |
| 單條更新 | 8ms | 1.5ms |
| 全量更新 | 95ms | 28ms |
| 內存佔用 | 15MB | 9MB |
Vue 3.6 的性能優勢主要來自:Proxy 的攔截效率高於 defineProperty,lazy reactive 避免了初始化時的全量代理,以及扁平化的依賴數據結構減少了 GC 壓力。
使用場景建議
- reactive:適合表單狀態、配置對象等結構穩定的對象數據
- ref:適合原始值、需要整體替換的對象、從 API 獲取的動態數據
- shallowReactive:適合大列表的根對象,只追蹤第一層屬性變更
- shallowRef:適合不需要深度響應的大數據對象,配合
triggerRef手動控制更新
小結
Vue 3.6 的響應式系統建立在 Proxy 和 effect 追蹤模型之上。reactive 通過 Proxy 攔截整個對象,支持嵌套延遲響應化;ref 通過 getter/setter 攔截 .value 訪問,解決了原始值無法被 Proxy 代理的問題。依賴收集通過 targetMap 維護 target → key → effect 的映射關係,trigger 時按 key 查找並執行相關 effect。批處理機制通過微任務隊列和 Set 去重實現,確保一次事件循環中只執行一次渲染。理解這些底層機制,才能在複雜場景中做出正確的響應式選擇,避免常見的響應式陷阱。
