浅谈watch与compute实现原理
watch和computed都基于响应式依赖追踪。watch通过副作用effect和调度器scheduler实现,当数据变化时执行回调,支持异步操作。computed同样基于effect,具有缓存机制,当依赖数据变化时重新计算,否则返回缓存结果,不支持异步。watch适用于复杂逻辑和异步操作,computed适用于频繁使用的计算结果,提高性能。
阴晴圆缺都休说,且喜人间好时节。
浅谈watch与compute实现原理
watch 和 computed 都是用于处理响应式数据的重要特性
watch
- 侦听一个或多个响应式数据源,并在数据源变化时调用所给的回调函数。
watch()默认是懒侦听的,即仅在侦听源发生变化时才执行回调函数。- 当直接侦听一个响应式对象时,侦听器会自动启用深层模式
watch类型:
typescript
// 侦听单个来源
function watch<T>(
source: WatchSource<T>,
callback: WatchCallback<T>,
options?: WatchOptions
): WatchHandle
// 侦听多个来源
function watch<T>(
sources: WatchSource<T>[],
callback: WatchCallback<T[]>,
options?: WatchOptions
): WatchHandle
type WatchCallback<T> = (
value: T,
oldValue: T,
onCleanup: (cleanupFn: () => void) => void
) => void
type WatchSource<T> =
| Ref<T> // ref
| (() => T) // getter
| T extends object
? T
: never // 响应式对象
interface WatchOptions extends WatchEffectOptions {
immediate?: boolean // 默认:false
deep?: boolean | number // 默认:false
flush?: 'pre' | 'post' | 'sync' // 默认:'pre'
onTrack?: (event: DebuggerEvent) => void
onTrigger?: (event: DebuggerEvent) => void
once?: boolean // 默认:false (3.4+)
}
interface WatchHandle {
(): void // 可调用,与 `stop` 相同
pause: () => void
resume: () => void
stop: () => void
}
watch参数
通过类型定义可以发现:
第一个参数是侦听器的源。这个来源可以是以下几种:
- 一个函数,返回一个值
- 一个
ref - 一个响应式对象
- 或者是以上的数组形式
第二个参数时一个回调函数,接受三个参数:新值、旧值、和一个用于注册副作用清理的回调函数。该回调函数会在副作用下一次重新执行前调用,可以用来清除无效的副作用,例如等待中的异步请求。当侦听多个来源时,回调函数接受两个数组,分别对应来源数组中的新值和旧值。
第三个可选的参数是一个对象,支持以下这些选项:
immediate:在侦听器创建时立即触发回调。第一次调用时旧值是undefined。deep:如果源是对象,强制深度遍历,以便在深层级变更时触发回调。在 3.5+ 中,此参数还可以是指示最大遍历深度的数字。参考深层侦听器。flush:调整回调函数的刷新时机。参考回调的刷新时机及watchEffect()。onTrack / onTrigger:调试侦听器的依赖。参考调试侦听器。once:(3.4+) 回调函数只会运行一次。侦听器将在回调函数首次运行后自动停止。
与 watchEffect() 相比,watch() 使我们可以:
- 懒执行副作用;
- 更加明确是应该由哪个状态触发侦听器重新执行;
- 可以访问所侦听状态的前一个值和当前值。
watch使用示例
-
侦听一个 getter 函数时
typescriptconst state = reactive({ count: 0 }) watch( () => state.count, (count, prevCount) => { /* ... */ } ) -
侦听一个
ref时typescriptconst count = ref(0) watch(count, (count, prevCount) => { /* ... */ }) -
侦听多个来源时
typescript// 回调函数中,第一个数组分别对应侦听来源的数据顺序、并且是新值、第二个数组是旧值 watch([fooRef, barRef], ([foo, bar], [prevFoo, prevBar]) => { /* ... */ }) -
副作用清理
typescriptwatch(id, async (newId, oldId, onCleanup) => { const { response, cancel } = doAsyncWork(newId) // 当 `id` 变化时,`cancel` 将被调用, // 取消之前的未完成的请求 onCleanup(cancel) data.value = await response }) // 3.5+ 中的副作用清理: import { onWatcherCleanup } from 'vue' watch(id, async (newId) => { const { response, cancel } = doAsyncWork(newId) onWatcherCleanup(cancel) data.value = await response })
watch原理
在watch源码中packages/runtime-core/src/apiWatch,可以看到watch内部的核心就是在doWatch。其实不管是 watchEffect、watch 还是组件内的 watch 选项,在执行时最终调用的都是 doWatch 中的逻辑
typescript
export function watch<T = any, Immediate extends Readonly<boolean> = false>(
source: T | WatchSource<T>,
cb: any,
options?: WatchOptions<Immediate>,
): WatchStopHandle {
return doWatch(source as any, cb, options)
}
// doWatch
function doWatch(
source: WatchSource | WatchSource[] | WatchEffect | object,
cb: WatchCallback | null,
{ immediate, deep, flush, onTrack, onTrigger }: WatchOptions = EMPTY_OBJ,
instance = currentInstance
): WatchStopHandle
在doWatch源码中(这里不放源码,有点长),主要做如下处理:
-
ref 类型
-
访问 getter 函数会获取到 source.value 值,直接解包。
-
forceTrigger 标记会根据是否是 shallowRef 来设置。
-
-
reactive 类型
- 访问 getter 函数直接返回 source,因为 reactive 的值不需要解包获取。
- 由于 reactive 中往往有多个属性,所以会将 deep 设置为 true,这里可以看出从外部给 reactive 设置 deep 是无效的。
-
数组 array 类型
- 将 isMultiSource 设置为 true。
- forceTrigger 会根据数组中是否存在 reactive 响应式对象来判断。
- getter 是一个数组形式,是 source 内各个元素的单个 getter 结果。
-
source 是函数 function 类型
- 如果有回调函数
- getter 就是 source 函数执行的结果,这种情况一般是 watch api 中的数据源以函数的形式传入。
- 如果没有回调函数,那么此时就是 watchEffect api 的场景了。
- 此时会为 watchEffect 设置 getter 函数,getter 函数逻辑如下:
- 如果组件实例已经卸载,则不执行,直接返回
- 否则执行 cleanup 清除依赖
- 执行 source 函数
- 此时会为 watchEffect 设置 getter 函数,getter 函数逻辑如下:
如果 source 不是以上的情况,则将 getter 设置为空函数,并且报出 source 不合法的警告
- 如果有回调函数
其实,所谓 watch的实现本质上就是利用了副作用 effect 以及一个调度器scheduler ,如下代码所示
typescript
const obj = reactive({
foo: 1
})
watch(obj, ()=>{
console.log('obj 数据变化')
})
obj.foo++
// 副作用
effect(()=> {
console.log(obj.foo)
}, {
scheduler(){
console.log('当值变化时')
}
})
-
当在一个副作用函数中访问响应式数据
obj.foo时,会在副作用函数与响应式数据之间建立联系,当响应式数据变化时,会触发副作用函数重新执行,但是,在这里,如果副作用函数存在scheduler选项,会触发scheduler调度函数执行,而非直接触发副作用函数执行。 -
从这个角度来看,其实
scheduler调度函数就相当于一个回调函数,而watch 的实现就是利用了这个特点。 -
此外,watch通过调用
watch的回调函数之前,会先执行一次 getter 函数(即传入的第一个参数),并将结果存储为旧值,当依赖的响应式数据发生变化时,重新执行 getter 函数,获取新值;在回调函数执行完毕后,将新值更新为旧值,以便下一次变化时使用。 -
watch简单实现如下:
typescriptfunction watch(source, cb) { let getter; if (typeof source === 'function') { getter = source; } else { // 如果不是一个getter 构造一个 getter = () => traverse(source); } // 定义旧值与新值 let oldValue, newValue; // 使用 effect 注册副作用函数时,开启 lazy 选项,并把返回值存储到 effectFn 中以便后续手动调用 const effectFn = effect( () => getter(), { lazy: true, scheduler() { // 在 scheduler 中重新执行副作用函数,得到的是新值 newValue = effectFn(); // 将旧值和新值作为回调函数的参数 cb(newValue, oldValue); // 更新旧值,不然下一次会得到错误的旧值 oldValue = newValue; } } ); // 手动调用副作用函数,拿到的值就是旧值 oldValue = effectFn(); } function traverse(value, seen = new Set()) { // 如果要读取的数据是原始值,或者已经被读取过了,那么什么都不做 if (typeof value !== 'object' || value === null || seen.has(value)) return; // 将数据添加到 seen 中,代表遍历地读取过了,避免循环引用引起的死循环 seen.add(value); // 假设 value 就是一个对象,使用 for...in 读取对象的每一个值,并递归地调用 traverse 进行处理 for (const k in value) { traverse(value[k], seen); } return value; }
compute
compute基于响应式依赖进行计算并返回结果的功能。它的特点是具有缓存性,即当依赖的响应式状态没有发生变化时,计算属性不会重新计算,从而提高性能。接受一个 getter 函数,返回一个只读的响应式 ref 对象。该 ref 通过 .value 暴露 getter 函数的返回值。它也可以接受一个带有 get 和 set 函数的对象来创建一个可写的 ref 对象。
compute类型
typescript
// 只读
function computed<T>(
getter: (oldValue: T | undefined) => T,
debuggerOptions?: DebuggerOptions
): Readonly<Ref<Readonly<T>>>
// 可写的
function computed<T>(
options: {
get: (oldValue: T | undefined) => T
set: (value: T) => void
},
debuggerOptions?: DebuggerOptions
): Ref<T>
compute示例
-
只读的计算属性 ref
typescriptconst count = ref(1) const plusOne = computed(() => count.value + 1) console.log(plusOne.value) // 2 plusOne.value++ // 错误 -
可写的计算属性 ref(getter/setter)
typescriptconst count = ref(1) const plusOne = computed({ get: () => count.value + 1, set: (val) => { count.value = val - 1 } }) plusOne.value = 1 console.log(count.value) // 0
compute原理
-
在源码中(
package/reactivity/src/compute),主要代码如下typescriptexport function computed<T>( getter: ComputedGetter<T>, debugOptions?: DebuggerOptions, ): ComputedRef<T> export function computed<T>( options: WritableComputedOptions<T>, debugOptions?: DebuggerOptions, ): WritableComputedRef<T> export function computed<T>( getterOrOptions: ComputedGetter<T> | WritableComputedOptions<T>, debugOptions?: DebuggerOptions, isSSR = false, ) { let getter: ComputedGetter<T> let setter: ComputedSetter<T> const onlyGetter = isFunction(getterOrOptions) if (onlyGetter) { getter = getterOrOptions setter = __DEV__ ? () => { warn('Write operation failed: computed value is readonly') } : NOOP } else { getter = getterOrOptions.get setter = getterOrOptions.set } const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR) return cRef as any }-
可以看到,如果传入一个函数,说明是一个只读的操作,创建一个只读的
getter,并且setter设置为一个空操作(开发环境是提示警告) -
如果是一个对象,并具有
get/set属性,将其赋值给getter和setter -
最后调用
ComputedRefImpl方法,其核心部分就在这里 -
ComputedRefImpl主要源码typescriptexport class ComputedRefImpl<T> { public dep?: Dep = undefined private _value!: T public readonly effect: ReactiveEffect<T> public readonly __v_isRef = true public readonly [ReactiveFlags.IS_READONLY]: boolean = false public _cacheable: boolean /** * Dev only */ _warnRecursive?: boolean constructor( private getter: ComputedGetter<T>, private readonly _setter: ComputedSetter<T>, isReadonly: boolean, isSSR: boolean, ) { this.effect = new ReactiveEffect( () => getter(this._value), () => triggerRefValue( this, this.effect._dirtyLevel === DirtyLevels.MaybeDirty_ComputedSideEffect ? DirtyLevels.MaybeDirty_ComputedSideEffect : DirtyLevels.MaybeDirty, ), ) this.effect.computed = this this.effect.active = this._cacheable = !isSSR this[ReactiveFlags.IS_READONLY] = isReadonly } get value() { // 获取原始数据,因为可能会被其他代理包裹,例如readonly() const self = toRaw(this) if ( (!self._cacheable || self.effect.dirty) && hasChanged(self._value, (self._value = self.effect.run()!)) ) { triggerRefValue(self, DirtyLevels.Dirty) } trackRefValue(self) if (self.effect._dirtyLevel >= DirtyLevels.MaybeDirty_ComputedSideEffect) { if (__DEV__ && (__TEST__ || this._warnRecursive)) { warn(COMPUTED_SIDE_EFFECT_WARN, `\n\ngetter: `, this.getter) } triggerRefValue(self, DirtyLevels.MaybeDirty_ComputedSideEffect) } return self._value } set value(newValue: T) { this._setter(newValue) } // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x get _dirty() { return this.effect.dirty } set _dirty(v) { this.effect.dirty = v } // #endregion }
由以上可知,compute的原理大致是:
- 响应式依赖追踪,建立起数据之间的依赖关系
- 依赖的响应式数据发生变化时,标记该Computed属性为脏数据,并在下次访问该属性时重新计算,并将计算结果缓存起来;如果依赖的响应式数据没有发生变化,直接返回上一次的计算结果,而不会重新计算
-
总结
- watch的实现本质上就是利用了副作用
effect以及一个调度器scheduler - watch是根据数据变化而进行回调操作,并能够获取新值和就值
- compute也是利用副作用
effect,并且是具有缓存机制的,当依赖的响应式数据发生变化时,标记该Computed属性为脏数据,并在下次访问该属性时重新计算,并将计算结果缓存起来;如果依赖的响应式数据没有发生变化,直接返回上一次的计算结果,而不会重新计算 - watch支持异步操作,而compute不支持
watch使用:
- 当需要在数据变化时执行异步操作,如调用后端API请求数据时,可以使用
watch。例如,在搜索框中输入关键词时,自动发起异步搜索请求,并更新搜索结果。 - 当需要在数据变化时执行一些复杂的逻辑或异步操作时,例如,浏览器自适应、监控路由对象、API请求等。
- 当一个数据变化影响多个数据时,使用watch可以更灵活地处理这些变化。
compute使用:
- 需要根据多个数据属性计算出一个新的数据属性时,使用computed。例如,计算总价格、过滤某些数据等。
- 当需要频繁使用某个计算结果时,使用computed可以避免重复计算,提高性能。