2019-6-6 seo達人
如果您想訂閱本博客內容，每天自動發到您的郵箱中， 請點這里
1. 如何實現一個響應式對象
最近在看 Vue 的源碼，其中最核心基礎的一塊就是 Observer/Watcher/Dep, 簡而言之就是，Vue 是如何攔截數據的讀寫， 如果實現對應的監聽，并且特定的監聽執行特定的回調或者渲染邏輯的。總的可以拆成三大塊來說。這一塊，主要說的是 Vue 是如何將一個 plain object 給處理成 reactive object 的，也就是，Vue 是如何攔截攔截對象的 get/set 的
我們知道，用 Object.defineProperty 攔截數據的 get/set 是 vue 的核心邏輯之一。這里我們先考慮一個最簡單的情況 一個 plain obj 的數據，經過你的程序之后，使得這個 obj 變成 Reactive Obj (不考慮數組等因素，只考慮最簡單的基礎數據類型，和對象):
如果這個 obj 的某個 key 被 get, 則打印出 get ${key} - ${val} 的信息
如果這個 obj 的某個 key 被 set, 如果監測到這個 key 對應的 value 發生了變化，則打印出 set ${key} - ${val} - ${newVal} 的信息。
對應的簡要代碼如下:
Observer.js
export class Observer {
constructor(obj) {
this.obj = obj;
this.transform(obj);
}
// 將 obj 里的所有層級的 key 都用 defineProperty 重新定義一遍, 使之 reactive
transform(obj) {
const _this = this;
for (let key in obj) {
const value = obj[key];
makeItReactive(obj, key, value);
}
}
}
function makeItReactive(obj, key, val) {
// 如果某個 key 對應的 val 是 object, 則重新迭代該 val, 使之 reactive
if (isObject(val)) {
const childObj = val;
new Observer(childObj);
}
// 如果某個 key 對應的 val 不是 Object, 而是基礎類型，我們則對這個 key 進行 defineProperty 定義
Object.defineProperty(obj, key, {
enumerable: true,
configurable: true,
get: () => {
console.info(`get ${key}-${val}`)
return val;
},
set: (newVal) => {
// 如果 newVal 和 val 相等，則不做任何操作(不執行渲染邏輯)
if (newVal === val) {
return;
}
// 如果 newVal 和 val 不相等，且因為 newVal 為 Object, 所以先用 Observer迭代 newVal, 使之 reactive, 再用 newVal 替換掉 val, 再執行對應操作(渲染邏輯)
else if (isObject(newVal)) {
console.info(`set ${key} - ${val} - ${newVal} - newVal is Object`);
new Observer(newVal);
val = newVal;
}
// 如果 newVal 和 val 不相等，且因為 newVal 為基礎類型, 所以用 newVal 替換掉 val, 再執行對應操作(渲染邏輯)
else if (!isObject(newVal)) {
console.info(`set ${key} - ${val} - ${newVal} - newVal is Basic Value`);
val = newVal;
}
}
})
}
function isObject(data) {
if (typeof data === 'object' && data != 'null') {
return true;
}
return false;
}
index.js
import { Observer } from './source/Observer.js';
// 聲明一個 obj,為 plain Object
const obj = {
a: {
aa: 1
},
b: 2,
}
// 將 obj 整體 reactive 化
new Observer(obj);
// 無輸出
obj.b = 2;
// set b - 2 - 3 - newVal is Basic Value
obj.b = 3;
// set b - 3 - [object Object] - newVal is Object
obj.b = {
bb: 4
}
// get b-[object Object]
obj.b;
// get a-[object Object]
obj.a;
// get aa-1
obj.a.aa
// set aa - 1 - 3 - newVal is Basic Value
obj.a.aa = 3
這樣，我們就完成了 Vue 的第一個核心邏輯， 成功把一個任意層級的 plain object 轉化成 reactive object
2. 如何實現一個 watcher
前面講的是如何將 plain object 轉換成 reactive object. 接下來講一下，如何實現一個watcher.
實現的偽代碼應如下:
偽代碼
// 傳入 data 參數新建新建一個 vue 對象
const v = new Vue({
data: {
a:1,
b:2,
}
});
// watch data 里面某個 a 節點的變動了，如果變動，則執行 cb
v.$watch('a',function(){
console.info('the value of a has been changed !');
});
// watch data 里面某個 b 節點的變動了，如果變動，則執行 cb
v.$watch('b',function(){
console.info('the value of b has been changed !');
})
Vue.js
// 引入將上面中實現的 Observer
import { Observer } from './Observer.js';
import { Watcher } from './Watcher.js';
export default class Vue {
constructor(options) {
// 在 this 上掛載一個公有變量 $options ,用來暫存所有參數
this.$options = options
// 聲明一個私有變量 _data ,用來暫存 data
let data = this._data = this.$options.data
// 在 this 上掛載所有 data 里的 key 值， 這些 key 值對應的 get/set 都被代理到 this._data 上對應的同名 key 值
Object.keys(data).forEach(key => this._proxy(key));
// 將 this._data 進行 reactive 化
new Observer(data, this)
}
// 對外暴露 $watch 的公有方法，可以對某個 this._data 里的 key 值創建一個 watcher 實例
$watch(expOrFn, cb) {
// 注意，每一個 watcher 的實例化都依賴于 Vue 的實例化對象, 即 this
new Watcher(this, expOrFn, cb)
}
// 將 this.keyName 的某個 key 值的 get/set 代理到 this._data.keyName 的具體實現
_proxy(key) {
var self = this
Object.defineProperty(self, key, {
configurable: true,
enumerable: true,
get: function proxyGetter() {
return self._data[key]
},
set: function proxySetter(val) {
self._data[key] = val
}
})
}
}
Watch.js
// 引入Dep.js, 是什么我們待會再說
import { Dep } from './Dep.js';
export class Watcher {
constructor(vm, expOrFn, cb) {
this.cb = cb;
this.vm = vm;
this.expOrFn = expOrFn;
// 初始化 watcher 時, vm._data[this.expOrFn] 對應的 val
this.value = this.get();
}
// 用于獲取當前 vm._data 對應的 key = expOrFn 對應的 val 值
get() {
Dep.target = this;
const value = this.vm._data[this.expOrFn];
Dep.target = null;
return value;
}
// 每次 vm._data 里對應的 expOrFn, 即 key 的 setter 被觸發，都會調用 watcher 里對應的 update方法
update() {
this.run();
}
run() {
// 這個 value 是 key 被 setter 調用之后的 newVal, 然后比較 this.value 和 newVal, 如果不相等，則替換 this.value 為 newVal, 并執行傳入的cb.
const value = this.get();
if (value !== this.value) {
this.value = value;
this.cb.call(this.vm);
}
}
}
對于什么是 Dep, 和 Watcher 里的 update() 方法到底是在哪個時候被誰調用的，后面會說
3. 如何收集 watcher 的依賴
前面我們講了 watcher 的大致實現，以及 Vue 代理 data 到 this 上的原理。現在我們就來梳理一下，Observer/Watcher 之間的關系，來說明它們是如何調用的.
首先, 我們要來理解一下 watcher 實例的概念。實際上 Vue 的 v-model, v-bind , {{ mustache }}, computed, watcher 等等本質上是分別對 data 里的某個 key 節點聲明了一個 watcher 實例.
<input v-model="abc">
<span>{{ abc }}</span>
<p :data-key="abc"></p>
...
const v = new Vue({
data:{
abc: 111,
}
computed:{
cbd:function(){
return `${this.abc} after computed`;
}
watch:{
abc:function(val){
console.info(`${val} after watch`)
}
}
}
})
這里，Vue 一共聲明了 4 個 watcher 實例來監聽abc, 1個 watcher 實例來監聽 cbd. 如果 abc 的值被更改，那么 4 個 abc - watcher 的實例會執行自身對應的特定回調(比如重新渲染dom,或者是打印信息等等)
不過，Vue 是如何知道，某個 key 對應了多少個 watcher, 而 key 對應的 value 發生變化后，又是如何通知到這些 watcher 來執行對應的不同的回調的呢？
實際上更深層次的邏輯是:
在 Observer階段，會為每個 key 都創建一個 dep 實例。并且，如果該 key 被某個 watcher 實例 get, 把該 watcher 實例加入 dep 實例的隊列里。如果該 key 被 set, 則通知該 key 對應的 dep 實例， 然后 dep 實例會將依次通知隊列里的 watcher 實例, 讓它們去執行自身的回調方法
dep 實例是收集該 key 所有 watcher 實例的地方.
watcher 實例用來監聽某個 key ，如果該 key 產生變化，便會執行 watcher 實例自身的回調
相關代碼如下:
Dep.js
export class Dep {
constructor() {
this.subs = [];
}
// 將 watcher 實例置入隊列
addSub(sub) {
this.subs.push(sub);
}
// 通知隊列里的所有 watcher 實例，告知該 key 的 對應的 val 被改變
notify() {
this.subs.forEach((sub, index, arr) => sub.update());
}
}
// Dep 類的的某個靜態屬性，用于指向某個特定的 watcher 實例.
Dep.target = null
observer.js
import {Dep} from './dep'
function makeItReactive(obj, key, val) {
var dep = new Dep()
Object.defineProperty(obj, key, {
enumerable: true,
configurable: true,
get: () => {
// 收集依賴！ 如果該 key 被某個 watcher 實例依賴，則將該 watcher 實例置入該 key 對應的 dep 實例里
if(Dep.target){
dep.addSub(Dep.target)
}
return val
},
set: (newVal) => {
if (newVal === val) {
return;
}
else if (isObject(newVal)) {
new Observer(newVal);
val = newVal;
// 通知 dep 實例, 該 key 被 set，讓 dep 實例向所有收集到的該 key 的 watcher 實例發送通知
dep.notify()
}
else if (!isObject(newVal)) {
val = newVal;
// 通知 dep 實例, 該 key 被 set，讓 dep 實例向所有收集到的該 key 的 watcher 發送通知
dep.notify()
}
}
})
}
watcher.js
import { Dep } from './Dep.js';
export class Watcher {
constructor(vm, expOrFn, cb) {
this.cb = cb;
this.vm = vm;
this.expOrFn = expOrFn;
this.value = this.get();
}
get() {
// 在實例化某個 watcher 的時候，會將Dep類的靜態屬性 Dep.target 指向這個 watcher 實例
Dep.target = this;
// 在這一步 this.vm._data[this.expOrFn] 調用了 data 里某個 key 的 getter, 然后 getter 判斷類的靜態屬性 Dep.target 不為null, 而為 watcher 的實例， 從而把這個 watcher 實例添加到 這個 key 對應的 dep 實例里。 巧妙！
const value = this.vm._data[this.expOrFn];
// 重置類屬性 Dep.target
Dep.target = null;
return value;
}
// 如果 data 里的某個 key 的 setter 被調用，則 key 會通知到 該 key 對應的 dep 實例, 該Dep實例， 該 dep 實例會調用所有 依賴于該 key 的 watcher 實例的 update 方法。
update() {
this.run();
}
run() {
const value = this.get();
if (value !== this.value) {
this.value = value;
// 執行 cb 回調
this.cb.call(this.vm);
}
}
}
總結：
至此， Watcher, Observer , Dep 的關系全都梳理完成。而這些也是 Vue 實現的核心邏輯之一。再來簡單總結一下三者的關系，其實是一個簡單的 觀察-訂閱 的設計模式, 簡單來說就是， 觀察者觀察數據狀態變化, 一旦數據發生變化，則會通知對應的訂閱者，讓訂閱者執行對應的業務邏輯 。我們熟知的事件機制，就是一種典型的觀察-訂閱的模式
Observer, 觀察者，用來觀察數據源變化.
Dep, 觀察者和訂閱者是典型的 一對多 的關系,所以這里設計了一個依賴中心,來管理某個觀察者和所有這個觀察者對應的訂閱者的關系, 消息調度和依賴管理都靠它。
Watcher, 訂閱者，當某個觀察者觀察到數據發生變化的時候，這個變化經過消息調度中心，最終會傳遞到所有該觀察者對應的訂閱者身上，然后這些訂閱者分別執行自身的業務回調即可
參考
Vue源碼解讀-滴滴FED
代碼參考
藍藍設計( www.ocunn.cn )是一家專注而深入的界面設計公司，為期望卓越的國內外企業提供卓越的UI界面設計、BS界面設計 、 cs界面設計 、 ipad界面設計 、 包裝設計 、 圖標定制 、 用戶體驗 、交互設計、 網站建設 、平面設計服務。