紀錄工作經驗、相關知識,解決技術相關問題。

Javascript, 新手 Jamp Holes

Vue.js 反應式系統 Proxy 與雙向綁定底層實作差異解析

Vue.js 反應式系統 Proxy 與雙向綁定底層實作差異解析 特色圖片

Vue.js 反應式系統負責在資料變動時自動更新畫面:Vue 2 用 Object.defineProperty 把屬性轉成 getter/setter 來攔截,Vue 3 對 reactive 物件改用 ES6 Proxy。兩種做法能攔截的操作不同,連帶影響新增屬性、陣列變動與大型資料結構的行為。

若想了解瀏覽器底層基礎原理與渲染效能細節,可先前往 〈瀏覽器渲染機制解析:DOM Tree、Reflow(重排)與 Repaint(重繪)效能優化〉 觀看,本文直接聚焦於 Vue.js 反應式系統的底層差異與實務排查。

您可以直接跳往 精簡程式碼範例 查看依賴追蹤與 shallowReactive 的用法。


一、 核心速查與常見瓶頸對照

在深入探討底層原理前,先對照 Vue 3 官方文件列出的常見陷阱與兩代機制的差異。

1. 常見寫法的陷阱

  • 直接替換 reactive() 物件:Vue 的反應式追蹤建立在屬性存取上,必須一直持有同一個 reactive 物件的參照。把全新物件賦值給原變數,原本的反應式連線就會斷開。
  • 解構 reactive 物件的屬性:把基本型別的屬性解構成區域變數,或把 state.count 直接傳進函式,拿到的只是一般數值,不再觸發 Proxy 的 get/set 捕捉器,因此追蹤不到後續變動。
  • 對大型資料結構使用深層響應式:Vue 預設是深層響應式,每次屬性存取都會經過 Proxy 捕捉器做依賴追蹤。官方效能文件指出,這在單次渲染要存取 10 萬以上屬性的大型陣列時才會明顯,可改用 shallowRef()/shallowReactive() 降低開銷。

2. 核心機制規格對照表

比較維度Vue 2 Object.definePropertyVue 3 Proxy 代理機制
攔截範圍把 data 內既有的屬性逐一轉成 getter/setter代理整個物件,Proxy 共有 13 種捕捉器 (Trap)
新增與刪除屬性偵測不到屬性新增與刪除,需用 Vue.set(vm.$set)或 Vue.delete可透過 set、deleteProperty、has 等捕捉器攔截新增、刪除與 in 運算子
陣列變動追蹤包裝 push、pop、shift、unshift、splice、sort、reverse 等變更方法;依索引設值與修改 length 偵測不到Proxy 的 set 捕捉器可收到索引寫入與 length 變更
初始化時機初始化時走訪 data 的所有屬性並轉成 getter/setterreactive() 在存取巢狀物件時才把它包成 reactive

二、 關鍵機制解析:底層規範與注意事項

1. MVVM 思想在現代前端框架的演進

MVVM 是 Model、View 與 ViewModel 三層分工的架構模式。Vue 官方文件的說法是:Vue 的設計並非嚴格對應 MVVM 模式,但部分受它啟發;文件慣例用 vm(ViewModel 的縮寫)代表 Vue 實例。

在 Vue 中,資料變動時畫面自動更新,靠的是依賴收集(Dependency Collection):元件渲染時讀取了哪些反應式屬性,系統就記下來,屬性之後被寫入時再通知對應的更新函式,開發者不必手動操作 DOM 節點。

2. Vue 2 Object.defineProperty 與 Vue 3 Proxy 差異

JavaScript 攔截屬性存取有 getter/setter 與 Proxy 兩種方式。Vue 官方文件說明,Vue 2 因瀏覽器支援限制只用 getter/setter;Vue 3 則對 reactive 物件使用 Proxy,對 ref 使用 getter/setter。

左側一排置物櫃沒有罩子、只有部分櫃門裝了黃色感測燈,右側一組置物櫃被玻璃罩整組罩住,對照逐一屬性攔截與整個物件代理
圖:逐一裝感測器與整個物件一起代理

Vue 2 的做法有兩項限制:

  1. 初始化時要走訪 data 的所有屬性,逐一用 Object.defineProperty 轉成 getter/setter,因此屬性必須事先存在於 data。
  2. 動態新增或刪除屬性時偵測不到,要改用 Vue.set(vm.$set)與 Vue.delete。

Vue 3 的 Proxy 代理的是「物件本身」。set、deleteProperty、has 等捕捉器能收到新增屬性、刪除屬性與 in 運算子的操作,不需要額外的輔助 API。下面這段腳本在 Node.js 22 執行,對照兩種機制攔截到的操作:

function defineReactive(obj, key, log) {
  let val = obj[key];
  Object.defineProperty(obj, key, {
    enumerable: true, configurable: true,
    get() { log.push(`get ${key}`); return val; },
    set(v) { log.push(`set ${key}=${v}`); val = v; }
  });
}

const log1 = [];
const o = { a: 1 };
Object.keys(o).forEach(k => defineReactive(o, k, log1));
o.a = 2;     // 既有屬性:攔截得到
o.b = 3;     // 新增屬性:攔截不到
delete o.a;  // 刪除屬性:攔截不到
console.log(log1);

const log2 = [];
const p = new Proxy({ a: 1 }, {
  set(t, k, v, r) { log2.push(`set ${String(k)}=${v}`); return Reflect.set(t, k, v, r); },
  has(t, k) { log2.push(`has ${String(k)}`); return Reflect.has(t, k); },
  deleteProperty(t, k) { log2.push(`delete ${String(k)}`); return Reflect.deleteProperty(t, k); }
});
p.a = 2; p.b = 3; 'b' in p; delete p.a;
console.log(log2);

執行結果如下:

[ 'set a=2' ]
[ 'set a=2', 'set b=3', 'has b', 'delete a' ]

Proxy 也不是沒有代價。Vue 官方文件指出,把 reactive 物件的屬性解構成區域變數後就不再被追蹤;reactive() 回傳的 Proxy 與原始物件用 === 比較也不相等,建議一律使用 Proxy 版本。

3. 模板編譯與 Virtual DOM 的關聯性

樣板經過編譯後會轉成渲染函式。Vue 官方文件把這套機制稱為編譯器輔助的 Virtual DOM(compiler-informed virtual DOM),包含三項優化:

  • 靜態快取(Cache Static):靜態節點的 vnode 只在首次渲染建立,之後重複使用,比對時可直接略過。
  • Patch Flags:動態綁定的元素帶有旗標,執行階段用位元運算判斷只需更新哪一類屬性。
  • Tree Flattening:每個區塊(block)只追蹤帶有 patch flag 的後代節點,重新渲染時只走訪這份攤平後的動態節點,靜態部分不會被拜訪。

4. 依賴收集運作原理

依賴收集由 track() 與 trigger() 兩個函式完成。依 Vue 官方文件的說明,元件更新函式會被包進一個 effect,執行期間這個 effect 是目前啟用的 effect;渲染中讀取反應式屬性時,track() 會把它加進該屬性的訂閱者 Set。

訂閱關係存放在全域的 WeakMap<target, Map<key, Set<effect>>>。屬性被寫入新值時,trigger() 找出該屬性的訂閱 effect 並逐一呼叫。

木製面板上的一支黃銅控制桿以三條纜線連接三盞桌燈,示意屬性被寫入時通知所有訂閱的更新函式
圖:寫入屬性後通知所有相依的更新函式

三、 實作範本:精簡程式碼範例

以下提供兩個範例,分別示範如何用 Proxy 寫出精簡的依賴追蹤,以及在 Vue 3 中用 shallowReactive 降低大型資料結構的代理開銷。

範本一:基於 Proxy 的精簡依賴追蹤實作

// 建立一個簡單的反應式系統範本,包含依賴收集與觸發機制
let activeEffect = null;

function effect(fn) {
  const effectFn = () => {
    activeEffect = effectFn;
    fn();
    activeEffect = null;
  };
  effectFn();
}

const targetMap = new WeakMap();

function track(target, key) {
  if (!activeEffect) return;
  let depsMap = targetMap.get(target);
  if (!depsMap) {
    targetMap.set(target, (depsMap = new Map()));
  }
  let deps = depsMap.get(key);
  if (!deps) {
    depsMap.set(key, (deps = new Set()));
  }
  deps.add(activeEffect);
}

function trigger(target, key) {
  const depsMap = targetMap.get(target);
  if (!depsMap) return;
  const deps = depsMap.get(key);
  if (deps) {
    deps.forEach(effectFn => effectFn());
  }
}

function reactive(raw) {
  return new Proxy(raw, {
    get(target, key, receiver) {
      track(target, key);
      const res = Reflect.get(target, key, receiver);
      // 若屬性值仍為物件,則進行惰性代理
      if (res !== null && typeof res === 'object') {
        return reactive(res);
      }
      return res;
    },
    set(target, key, value, receiver) {
      const oldValue = target[key];
      const result = Reflect.set(target, key, value, receiver);
      if (oldValue !== value) {
        trigger(target, key);
      }
      return result;
    }
  });
}

// 測試用例
const state = reactive({ count: 0 });
effect(() => {
  console.log(`目前計數值為:${state.count}`);
});
state.count++; // 觸發更新,輸出:目前計數值為:1

這個範本在 Node.js 22 執行,輸出 目前計數值為:0 與 目前計數值為:1 兩行。它省略了 Vue 實際實作的細節,例如每次讀取巢狀物件都會建立新的 Proxy,只適合用來理解 track() 與 trigger() 的流程。

範本二:大型資料結構與 shallowReactive 效能優化範本

import { shallowReactive, readonly } from 'vue';

// 針對擁有數萬筆資料的 API 回傳物件,使用 shallowReactive 避免過度代理
const largeDataset = shallowReactive({
  meta: { total: 50000, version: '1.0' },
  items: new Array(50000).fill(0).map((_, i) => ({ id: i, name: `項目 ${i}` }))
});

// 對外只提供唯讀版本,避免內部資料被意外修改
export function useOptimizedData() {
  const safeData = readonly(largeDataset);

  const updateMetaTotal = (newTotal) => {
    // shallowReactive 只有根級屬性是反應式的,
    // 所以要替換整個 meta 物件才會觸發更新;內部 5 萬筆物件不會被 Proxy 包裝
    largeDataset.meta = { ...largeDataset.meta, total: newTotal };
  };

  return {
    safeData,
    updateMetaTotal
  };
}

Vue 官方文件說明,shallowReactive() 只有根級屬性是反應式的,巢狀物件原樣保留。因此直接寫 largeDataset.meta.total = newTotal 不會觸發任何更新,必須像上面這樣替換第一層的 meta。readonly() 則是深層的,對巢狀屬性寫入會出現警告且不會生效。


四、 常見問題與排錯(Q&A)

Q1:為什麼 Vue 3 放棄 Object.defineProperty 改用 ES6 Proxy 實作反應式系統?

結論:兩者能攔截的操作範圍不同,Vue 3 對 reactive 物件改用 Proxy。

  • 問題原因:Object.defineProperty 針對單一既有屬性設定 getter/setter,Vue 2 因此偵測不到屬性新增與刪除,陣列也偵測不到依索引設值與修改 length。
  • 解法:Proxy 代理整個物件,13 種捕捉器涵蓋 get、set、has、deleteProperty 等操作,不需要 Vue.set/Vue.delete 這類輔助 API。Vue 官方文件把 Vue 2 只用 getter/setter 歸因於當時的瀏覽器支援限制。

Q2:Proxy 實作的反應式系統是否會對效能造成影響?

結論:資料量大時會有可感受的開銷,一般情境不明顯。

  • 問題原因:Vue 預設是深層響應式,每次屬性存取都會經過 Proxy 捕捉器做依賴追蹤。官方效能文件指出,這在單次渲染要存取 10 萬以上屬性的大型陣列時才會明顯。
  • 解法:不需要追蹤的大型資料,改用 shallowRef()/shallowReactive(),或用 markRaw() 標記為永遠不轉成 Proxy。代價是巢狀物件必須視為不可變,要替換根級狀態才會觸發更新。

Q3:Vue.js 的雙向綁定(v-model)和資料流是什麼關係?

結論:v-model 是語法糖,底層仍是單向的屬性傳入加事件回傳。

  • 問題原因:看到 v-model 容易以為資料會自己雙向流動。
  • 解法:在原生 <input> 上,編譯器把 v-model 展開成 :value 綁定加 @input 監聽;用在元件上則展開成 modelValue prop 加 update:modelValue 事件。另外,狀態變動後的 DOM 更新是非同步的:Vue 會緩衝到下一個 tick,確保每個元件在一輪更新中只更新一次。

Q4:使用 reactive() 處理大型資料結構時,如何降低不必要的開銷?

結論:先判斷資料是否真的需要深層追蹤。

  • 問題原因:reactive() 會在存取時把巢狀物件逐層轉成 reactive,大型資料結構的每次屬性存取都帶有追蹤成本。
  • 解法:資料只需要根級追蹤時,改用 shallowReactive(),並按官方效能文件的做法,以替換根級狀態的方式觸發更新。衍生的運算結果可用 computed:它依反應式依賴快取,依賴沒變就不會重跑 getter。

Q5:模板編譯階段如何優化 Virtual DOM 的比對效率?

結論:靠編譯器在編譯期提供的提示,執行階段少做工。

  • 問題原因:純粹的 Virtual DOM 重新渲染時,靜態內容也得重新建立 vnode 並比對。
  • 解法:Vue 3 編譯器輸出靜態快取、Patch Flags 與 Tree Flattening(見第二章第 3 節),讓渲染器略過靜態節點,只處理帶旗標的動態節點。

Q6:依賴收集會不會造成記憶體殘留?

結論:訂閱表本身以 WeakMap 儲存,元件內同步建立的 watcher 會自動停止;非同步建立的要自己停止。

  • 問題原因:effect 若一直留在屬性的訂閱 Set 裡,就會持續被觸發並佔用記憶體。
  • 解法:依賴關係存在 WeakMap<target, Map<key, Set<effect>>>,WeakMap 不會阻止鍵物件被垃圾回收。在 setup() 或 <script setup> 內同步宣告的 watcher 會在元件卸載時自動停止;在 setTimeout 等非同步回呼裡建立的 watcher 不會綁定元件,必須用 watch/watchEffect 回傳的函式手動停止。

Q7:如何用瀏覽器開發工具檢查反應式系統造成的記憶體流失?

結論:用 Chrome DevTools 的 Memory 面板拍 Heap Snapshot 比對。

  • 問題原因:未停止的 watcher 或全域事件監聽,可能讓已卸載的元件與 DOM 節點無法被回收。
  • 解法:依序操作:
    1. 開啟 DevTools 的 Memory 面板,選 Heap snapshot,按 Take snapshot(拍攝前會先執行垃圾回收)。
    2. 重複掛載與卸載元件後再拍一次,用 Comparison 檢視兩份快照的差異。
    3. 選取疑似洩漏的物件,在下方 Retainers 區段查看是哪些物件仍指向它,常見的是遺留的 Detached DOM 子樹。

參考資料與延伸閱讀

發佈留言