在从vue(v2.7.10)源码分析vue是如何收集依赖和触发依赖这篇文章中我们讲了vue是怎么收集依赖的。其中computed的实现原理和这个密切相关，接下来我们看看computed的实现原理。
基础代码如下：
<template>
<div>
{{getA}}
<button @click="addModule">新增</button>
</div>
</template>
<script>
export default {
name: "TestWebpackTest",
mounted() {
console.log(this);
},
data() {
return {
num: 1,
a:2
};
},
computed:{
getA(){
return this.a
}
},
methods: {
addModule() {
this.a++;
}
}
};
</script>
<style lang="scss">
div {
.test {
width: 10px;
height: 15px;
background-color: blue;
}
}
</style>定义依赖
直接上代码，在执行render函数实例化TestWebpackTest组件的时候会执行下面的方法：
Vue.extend = function (extendOptions) {
...
if (Sub.options.computed) {
initComputed(Sub);
}
...
};在该方法中会执行initComputed方法，该方法遍历computed并执行defineComputed方法：
function initComputed(Comp) {
var computed = Comp.options.computed;
for (var key in computed) {
defineComputed(Comp.prototype, key, computed[key]);
}
}
var sharedPropertyDefinition = {
enumerable: true,
configurable: true,
get: noop,
set: noop
};
// key: "getA" target: Vue {constructor: ƒ} userDef:ƒ getA()
function defineComputed(target, key, userDef) {
var shouldCache = !isServerRendering(); // true
if (isFunction(userDef)) {
sharedPropertyDefinition.get = shouldCache
? createComputedGetter(key)
: createGetterInvoker(userDef);
sharedPropertyDefinition.set = noop;
}
else {
...
}
...
Object.defineProperty(target, key, sharedPropertyDefinition);
}
主要执行了createComputedGetter方法设置computed函数getA的get方法：
// key: "getA"
function createComputedGetter(key) {
return function computedGetter() {
var watcher = this._computedWatchers && this._computedWatchers[key];
if (watcher) {
if (watcher.dirty) {
watcher.evaluate();
}
if (Dep.target) {
if (Dep.target.onTrack) {
Dep.target.onTrack({
effect: Dep.target,
target: this,
type: "get" ,
key: key
});
}
watcher.depend();
}
return watcher.value;
}
};
}
该方法执行过程在收集依赖部分分析。返回该函数后执行Object.defineProperty(target, key, sharedPropertyDefinition)，给当前的vm设置getA响应式。至此设置响应完毕。
收集依赖
收集依赖发生在执行组件渲染过程，会通过_vm.getA触发computed的get方法。
var render = function render() {
var _vm = this,
_c = _vm._self._c
return _c("div", [
_vm._v("\n " + _vm._s(_vm.getA) + "\n "),
_c("button", { on: { click: _vm.addModule } }, [_vm._v("新增")]),
])
}
会获取当前的computed函数生成的watcher，继续执行watcher.evaluate()方法：
var watcher = this._computedWatchers && this._computedWatchers[key];
if (watcher) {
if (watcher.dirty) { // true
watcher.evaluate();
}
if (Dep.target) {
if (Dep.target.onTrack) {
Dep.target.onTrack({
effect: Dep.target,
target: this,
type: "get" ,
key: key
});
}
watcher.depend();
}
return watcher.value;
}
Watcher.prototype.evaluate = function () {
this.value = this.get();
this.dirty = false;
};
调用当前watcher的get方法，首先设置当前的Dep.target为当前的watcher，然后执行this.getter方法，该方法为getA方法，相当于执行该函数。
Watcher.prototype.get = function () {
pushTarget(this);
var value;
var vm = this.vm;
try {
value = this.getter.call(vm, vm);
}
catch (e) {
...
}
finally {
// "touch" every property so they are all tracked as
// dependencies for deep watching
if (this.deep) {
traverse(value);
}
popTarget();
this.cleanupDeps();
}
return value;
};
由于依赖于a变量，所以会触发a变量的get方法，并执行dep.depend方法
var value = getter ? getter.call(obj) : val;
if (Dep.target) {
{
dep.depend({
target: obj,
type: "get" ,
key: key
});
}
...
}
return isRef(value) && !shallow ? value.value : value;
...
Dep.prototype.depend = function (info) {
if (Dep.target) {
Dep.target.addDep(this);
if (info && Dep.target.onTrack) {
Dep.target.onTrack(__assign({ effect: Dep.target }, info));
}
}
};
...
Watcher.prototype.addDep = function (dep) {
var id = dep.id;
if (!this.newDepIds.has(id)) {
this.newDepIds.add(id);
this.newDeps.push(dep);
if (!this.depIds.has(id)) {
dep.addSub(this);
}
}
};
当前的Dep.target是getA的watcher实例，a变量会找到订阅者(getA的watcher)，并在该watcher的newDeps里添加该变量的dep（this.newDeps.push(dep)），然后该变量会把getA的watcher加入自己的依赖（dep.addSub(this)）。从而建立了getA和num之间的联系。接下来执行popTarget()和this.cleanupDeps()将当前Dep.target置为组件的watcher，然后newDeps的值赋给deps。至此watcher.evaluate()执行完后this.getter.call(vm, vm)执行完毕，返回a的value。
触发依赖
当变量发生变化时会触发该变量的set方法：
function reactiveSetter(newVal) {
var value = getter ? getter.call(obj) : val;
...
else if (!shallow && isRef(value) && !isRef(newVal)) {
value.value = newVal;
return;
}
else {
val = newVal;
}
childOb = !shallow && observe(newVal, false, mock);
{
dep.notify({
type: "set" ,
target: obj,
key: key,
newValue: newVal,
oldValue: value
});
}
}
主要执行dep.notify方法：
Dep.prototype.notify = function (info) {
// stabilize the subscriber list first
var subs = this.subs.slice();
...
for (var i = 0, l = subs.length; i < l; i++) {
...
subs[i].update();
}
};
Watcher.prototype.update = function () {
if (this.lazy) {
this.dirty = true;
}
else if (this.sync) {
this.run();
}
else {
queueWatcher(this);
}
};主要执行subs[i].update()方法，当前的变量a有两个dep，computed的lazy为true不会继续执行。第二个dep为组件的watcher，执行该watcher的update方法重新渲染刷新页面。
总结
- 在组件实例化的时候会遍历computed设置computed的get方法并设置Dep.target为当前computed的watcher。
- 在执行渲染模板方法的时候会触发该computed的get方法。
- 会执行computed函数，当该函数里获取变量时会触发变量的get方法。该变量会通过Dep.target获取当前的watcher并添加自己的dep（相当于记录了订阅了哪些变量），也就是说获取变量的时候会订阅该变量，该变量也会在自己的依赖dep添加watcher（记录订阅者，发生变化时会通知订阅者）。
- 当前变量发生改变时会循环触发该变量的dep的update方法刷新页面。其中computed方法由于已经获取最新值所以只需要执行组件的update方法。
到此这篇关于Vue computed实现原理深入讲解的文章就介绍到这了,更多相关Vue computed内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！
