13-响应式系统演进_版本化动态依赖管理机制解析-Vue3.4

作者：袖梨 2026-05-29

Vue3.4通过版本化机制优化了动态依赖收集性能，解决了此前位运算方案的局限性。本文将详细解析这一创新机制的工作原理与实现细节。

什么是动态依赖

动态依赖指副作用函数中依赖的响应式数据会随程序执行状态变化而变化。举例说明：

const state = reactive({ a: '掘金签约作者', b: 'Cobyte', flag: true })effect(() => {
  if (state.flag) {
    // 依赖 state.a
    console.log(state.a);
  } else {
    // 依赖 state.b
    console.log(state.b);
  }
});state.flag = false
state.a = '小前端'

运行结果如下：

掘金签约作者
Cobyte
Cobyte

当state.flag为false时，改变state.a仍触发副作用执行，说明存在冗余依赖。动态依赖的变化过程可分为两个阶段：

初始状态 (state.flag = true)：
1. 依赖：state.flag、state.a
2. 不依赖：state.b
状态变化后 (state.flag = false)：
1. 依赖：state.flag、state.b
2. 不依赖：state.a

若无正确清理机制，effect会保留过期依赖导致性能浪费。

核心机制分析

初始化时effect的deps收集到两个依赖：

deps = [ dep_flag, dep_a ]

执行以下代码后：

state.flag = false
state.a = '小前端'

deps变为：

deps = [ dep_flag, dep_a, dep_b ]

此时需删除冗余依赖dep_a。解决方案是在更新时将dep_a替换为dep_b，同时删除dep_a中的对应effect。

对于更复杂的情况：

const state = reactive({ a: '掘金签约作者', b: 'Cobyte', flag: true })effect(() => {
  if (state.flag) {
    console.log(state.a);
    console.log(state.b);
  } else {
    console.log(state.b);
  }
});state.flag = false
state.a = '小前端'

依赖变化为：

deps = [ dep_flag, dep_b, dep_b ]

需删除最后一个dep_b。引入_depsLength记录实际使用依赖数量，通过版本标记比对确保正确清理。

故意重新收集依赖

Vue3.4在每次更新时都进行依赖收集，为此添加_trackId和_depsLength变量，并移除位运算优化代码。

class ReactiveEffect {
    deps = []
    _runnings = 0
    _dirtyLevel = DirtyLevels.Dirty
+    _trackId = 0
+    _depsLength = 0
    run () {
        this._dirtyLevel = DirtyLevels.NotDirty
        try {
            activeEffect = this;
            effectStack.push(this);
            this._runnings++
+            this._trackId++
+            this._depsLength = 0
            return this._fn();
        } finally {
            this._runnings--
            effectStack.pop();
            activeEffect = effectStack[effectStack.length - 1];
        }
    }
}

Map 同样具有去重功能

将依赖存储从Set改为Map，利用其键唯一性实现去重：

function track(target, key) {
    if (shouldTrack  && activeEffect) {
        let depsMap = targetMap.get(target)
        if (!depsMap) depsMap = new Map()
        let deps = depsMap.get(key)
        if (!deps) {
+          deps = new Map();
          depsMap.set(key, deps)
        }
+       trackEffect(activeEffect, deps)
    }
}

实现动态依赖优化

关键改进是在存储新依赖前检查并清理旧依赖：

function trackEffect(effect, dep) {
    dep.set(effect, effect._trackId)
+    const oldDep = effect.deps[effect._depsLength]
+    if (oldDep !== dep) {
+      if (oldDep) oldDep.delete(effect)
+      effect.deps[effect._depsLength++] = dep
+    } else {
+      effect._depsLength++
+    }
}

清理无效依赖

添加后置清理逻辑处理未重新收集的依赖：

class ReactiveEffect {
    run () {
        try {
            // ...
        } finally {
+            postCleanupEffect(this);
            // ...
        }
    }
}+ function postCleanupEffect(effect) {
+  if (effect.deps.length > effect._depsLength) {
+    for (let i = effect._depsLength; i < effect.deps.length; i++) {
+        cleanupDepEffect(effect.deps[i], effect)
+    }
+    effect.deps.length = effect._depsLength
+  }
+ }
+ function cleanupDepEffect(dep, effect) {
+  const trackId = dep.get(effect)
+  if (trackId !== effect._trackId) dep.delete(effect)
+ }