视频加载失败

Vue响应式原理

1508 字
8 分钟
Vue响应式原理

从 defineProperty 到 Proxy:Vue 响应式原理全解析#

一、Object.defineProperty 的四个数据描述符#

Object.defineProperty 用于在一个对象上定义新属性,或修改已有属性,并返回此对象。Vue2 的响应式正是建立在它之上的。它有四个核心数据描述符。

1. value:属性的值#

类型:any,默认值:undefined

const obj = {}
Object.defineProperty(obj, 'name', {
value: '张三', // 为 obj.name 赋值为 张三
writable: false // 默认就是 false,不可修改
})
obj.name = 'test' // 严格模式下会报错;非严格模式静默失败(无任何效果)
console.log(obj.name) // '张三'

2. writable:是否可修改值#

类型:Boolean,默认值:false

const obj = {}
Object.defineProperty(obj, 'name', {
value: '张三',
writable: true // 允许修改
})
obj.name = 'test'
console.log(obj.name) // 'test'

3. enumerable:是否可枚举#

类型:Boolean,默认值:false

const obj = { age: 18 }
Object.defineProperty(obj, 'name', {
value: '张三',
writable: false,
enumerable: false // 不可枚举
})
console.log(Object.keys(obj)) // ['age'],name 不会被枚举出来
console.log('name' in obj) // true,但属性确实存在于 obj 上

4. configurable:是否可删除 / 可重新定义描述符#

类型:Boolean,默认值:false

const obj = {}
Object.defineProperty(obj, 'name', {
value: '张三',
configurable: false
})
const res = delete obj.name
console.log(res) // false,删除失败
console.log('name' in obj) // true
Object.defineProperty(obj, 'name', { value: '李四' })
// TypeError: Cannot redefine property: name

二、Vue2:用 get / set 实现数据劫持#

利用 defineProperty 的 get / set 拦截属性的读写,就构成了 Vue2 响应式的雏形:

// 利用 defineProperty 实现数据劫持
function observe(obj) {
if (!isObject(obj)) return
Object.keys(obj).forEach((key) => {
let value = obj[key]
observe(value) // 递归处理嵌套对象
Object.defineProperty(obj, key, {
get() {
console.log('读取值', value)
return value
},
set(newValue) {
if (newValue !== value) {
console.log('新值', newValue)
observe(newValue) // 新值也要劫持
value = newValue
}
}
})
})
}

这样实现的缺点:

  • 不能劫持数组:需要对数组的变更方法(push、splice 等)进行重写;
  • 不能检测属性的新增与删除:所以 Vue2 提供了 Vue.set / Vue.delete;
  • 初始化时需要递归遍历整个对象,遇到层级较深的对象,性能会受到影响。

三、完整的依赖收集:Dep 与 Watcher#

光能拦截读写还不够——读的时候要知道”谁在用这个数据”(依赖收集),写的时候要知道”该通知谁更新”(派发更新)。这就是 Dep 与 Watcher 的分工:

  • Dep(依赖收集器):每个响应式属性对应一个 Dep 实例,管理该属性的所有订阅者;
  • Watcher(观察者):依赖的使用者(如渲染函数),数据变化时被重新执行。
// ============ 数据对象 ============
const obj = {
name: '李四',
age: 18
}
// ============ 工具函数 ============
const isObject = (obj) => {
return typeof obj === 'object' && obj !== null
}
// ============ 依赖收集器 Dep ============
// 每个响应式属性都有一个 Dep 实例,负责管理该属性的所有订阅者
class Dep {
constructor() {
this.subs = [] // 存放所有订阅者(Watcher 实例)
}
// 收集依赖:将当前 Watcher 添加到订阅列表
depend() {
if (Dep.target) {
this.subs.push(Dep.target)
}
}
// 派发更新:通知所有订阅者执行 update 方法
notify() {
this.subs.forEach((sub) => sub.update())
}
}
// Dep.target 是静态属性:全局指向当前正在收集依赖的 Watcher
// ============ 观察者 Watcher ============
class Watcher {
constructor(fn) {
this.fn = fn // 保存要执行的函数
this.get() // 立即执行一次,完成依赖收集
}
get() {
Dep.target = this // 标记当前正在收集依赖的 Watcher
this.fn() // 执行函数,触发属性 getter,完成依赖收集
Dep.target = null // 清除全局标记
}
// 依赖的数据变化时,重新执行函数
update() {
this.get()
}
}
// ============ 依赖映射管理 ============
// 全局依赖映射表:target -> key -> Dep
const map = new Map()
function getDep(target, key) {
let depMap = map.get(target)
if (!depMap) {
depMap = new Map()
map.set(target, depMap)
}
let dep = depMap.get(key)
if (!dep) {
dep = new Dep()
depMap.set(key, dep)
}
return dep
}
// ============ 响应式核心 ============
function defineReactive(obj, key, value) {
observe(value) // 递归处理嵌套对象
const dep = getDep(obj, key)
Object.defineProperty(obj, key, {
get() {
dep.depend() // 依赖收集:getter 中记录当前 Watcher
return value
},
set(newValue) {
if (newValue !== value) {
value = newValue
dep.notify() // 派发更新:setter 中通知所有订阅者
}
}
})
}
function observe(obj) {
if (!isObject(obj)) return
Object.keys(obj).forEach((key) => defineReactive(obj, key, obj[key]))
}
// ============ 初始化 ============
observe(obj)
// ============ 创建 Watcher,自动收集依赖 ============
function function1() {
console.log('姓名', obj.name)
}
function function2() {
console.log('年龄', obj.age)
}
new Watcher(function1) // function1 依赖 obj.name
new Watcher(function2) // function2 依赖 obj.age
// ============ 触发更新 ============
obj.age++ // 触发 setter → notify → function2 重新执行

整条链路:getter 触发 dep.depend() 收集当前 Watcher → setter 触发 dep.notify() 通知所有 Watcher 重新执行。这正是 Vue2”数据驱动视图”的最小模型。

四、Vue3:Proxy 版数据劫持#

Proxy 是 ES6 引入的对象,可以对对象的各种操作进行拦截(属性访问、赋值、in、delete、函数调用等共 13 种),而不仅仅是 get / set。

function observe(obj) {
if (!isObject(obj)) return obj
return new Proxy(obj, {
get(target, prop, receiver) {
const value = Reflect.get(target, prop, receiver)
console.log('读取值', value)
// 惰性劫持:访问到嵌套对象时才递归代理
if (isObject(value)) {
return observe(value)
}
return value
},
set(target, prop, value, receiver) {
console.log('新值', value)
// Reflect.set 返回是否设置成功的布尔值
return Reflect.set(target, prop, value, receiver)
}
})
}

利用 Proxy 即可解决 defineProperty 方案的缺陷。

五、两种方案对比#

维度defineProperty(Vue2)Proxy(Vue3)
拦截能力仅 get / setget、set、has、deleteProperty 等 13 种
数组需重写变更方法天然支持(索引和 length 变化都会经过 set)
新增 / 删除属性检测不到(需 Vue.set / Vue.delete)天然支持
嵌套对象初始化时一次性递归劫持惰性劫持:访问到时才代理,初始化更快
拦截粒度逐属性定义直接代理整个对象
兼容性IE9+不兼容 IE,且无法被 polyfill

小结#

Vue 响应式的演进本质上是 JS 语言能力的演进:defineProperty 只能逐个属性拦截读写,所以 Vue2 需要递归遍历 + 重写数组方法 + 提供 Vue.set 来弥补盲区;Proxy 能整体代理对象的所有操作,Vue3 因此甩掉了全部补丁,还顺带用”惰性劫持”优化了初始化性能。

支持与分享

如果这篇文章对你有帮助,欢迎分享给更多人或打赏支持!

打赏
Vue响应式原理
https://firefly.cuteleaf.cn/posts/vue响应式原理/
作者
MIRAI
发布于
2026-10-30
许可协议
CC BY-NC-SA 4.0

评论区

Profile Image of the Author
MIRAI
心之所向,素履以往
公告
欢迎来到我的博客!
分类
标签
最新动态
站点统计
文章
11
分类
1
标签
10
总字数
19,512
运行时长
0 天
最后活动
0 天前
站点信息
构建平台
GitHub Actions
博客版本
Firefly v6.16.8
文章许可
CC BY-NC-SA 4.0
文章目录