Skip to content

Vue 3.6 響應式系統原始碼解析:ref 與 reactive 的實作差異

Vue 3 的響應式系統是一次徹底的架構重寫。從 Vue 2 的 Object.defineProperty 到 Vue 3 的 Proxy,不僅是 API 的變化,更是響應式模型從「屬性劫持」到「物件代理」的範式轉變。Vue 3.6 在此基礎上進一步最佳化了 effect 排程和記憶體管理。本文從原始碼層面剖析 ref 和 reactive 的實作差異。

響應式系統的核心模型 ​

Vue 的響應式系統由三個核心部分組成:

  1. 響應式資料:透過 Proxy 攔截資料的讀寫操作
  2. 依賴收集(track):在資料被讀取時,記錄當前正在執行的 effect
  3. 觸發更新(trigger):在資料被修改時,通知所有依賴此資料的 effect 重新執行
effect 執行 → 讀取響應式資料 → track 收集依賴 → 資料變更 → trigger 通知 effect → effect 重新執行

這個模型的關鍵在於:effect 執行期間讀取的所有響應式資料,都會與該 effect 建立關聯。當任何關聯資料變更時,effect 就會被重新執行。

reactive 的實作 ​

reactive 的核心是 new Proxy(target, handlers),攔截 get、set、has、deleteProperty 等操作。

typescript
// 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。

typescript
// 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 的核心差異 ​

維度reactiveref
支援的資料型別僅物件物件 + 原始值
代理機制Proxy 攔截整個物件getter/setter 攔截 .value
巢狀響應化自動遞迴(lazy)原始值不遞迴,物件委託給 reactive
依賴儲存target → key → dep 映射ref 實例上的單一 dep
存取方式直接存取屬性 state.count需要 .value
模板自動解包不需要自動解包(編譯器處理)
替換整個物件失效(Proxy 綁定在原物件上)可以(替換 _value)

最後一點經常是 bug 來源:

typescript
// 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 巢狀改為更扁平的結構:

typescript
// 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 函式管理:

typescript
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 重新執行前,先清除所有舊的依賴關係。這解決了分支切換問題——當條件分支改變時,之前分支中收集的依賴應該被清理。

typescript
function cleanupEffect(effect: ReactiveEffect) {
  const { deps } = effect
  for (let i = 0; i < deps.length; i++) {
    deps[i].effects.delete(effect)
  }
  deps.length = 0
}

觸發更新(trigger)的完整流程 ​

typescript
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)和微任務佇列實現。

typescript
// 批次處理佇列
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), // 使用排程器而非立即執行
  })
}

批次處理的效果:

typescript
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 ​

typescript
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
  },
}

使用場景:

typescript
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) // ✅ 手動通知更新

手寫簡化版響應式系統 ​

將上述概念整合為一個可執行的簡化版:

typescript
// ===== 簡化版響應式系統 =====

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.7Vue 3.6
初始化時間120ms45ms
單條更新8ms1.5ms
全量更新95ms28ms
記憶體佔用15MB9MB

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 去重實現,確保一次事件迴圈中只執行一次渲染。理解這些底層機制,才能在複雜場景中做出正確的響應式選擇,避免常見的響應式陷阱。

MIT Licensed