vue響應式原理及依賴收集。

vue

Vue經過設定對象屬性的setter/getter方法來監聽數據的變化，經過getter進行依賴收集，而每一個setter方法就是一個觀察者，在數據變動的時候通知訂閱者更新視圖。

將數據data變成可觀察的（observable）

那麼Vue是如何將全部data下面的屬性變成可觀察的呢？

function obsever(value,cb){
    Object.keys(value).forEach((key)=>defineReactive(value,key,value[key],cb))
}
function defineReactive(obj,key,val,cb){
    Object.defineProperty(obj,key,{
        enumerable;true,
        configurable:true,
        get:()=>{
            /*依賴收集*/
            return val;
        },
        set:newVal=>{
            val=newVal;
            cb();
        }
    })
}
class Vue{
    constructor(options){
        this._data = options.data;
        obsever(this._data,options.render)
    }
}

let app = new Vue({
    el:'#app',
    data:{
        text:'text',
        text2:'text2'
    },
    render(){
        console.log('render')
    }
})

爲了便於理解，首先考慮一種最簡單的狀況，不考慮數組等狀況，代碼如上所示。在initData中會調用observe這個函數將Vue的數據設置成observable的。當_data數據發生改變的時候就會觸發set，對訂閱者進行回調（在這裏是render）。
那麼問題來了，須要對app._data.text操做纔會觸發set。爲了偷懶，咱們須要一種方便的方法經過app.text直接設置就能觸發set對視圖進行重繪。那麼就須要到代理。

代理

咱們能夠在Vue的構造函數constructor中爲data執行一個代理proxy。這樣咱們就把data上面的屬性代理到了vm實例上。

_proxy.call(this,options.data);//構造函數
//代理
function _proxy(data){
    const that = this;
    Object.keys(data).forEach(key=>{
        configurable:true,
        enumerable:true,
        get:function proxyGetter(){
            return that._data[key]
        },
        set:function proxySetter(val){
            that._data[key] = val;
        }
    })
}

咱們就能夠用app.text代替app._data.text了。

爲何要依賴收集

先看下面這段代碼

new Vue({
    template:`<div>
                <span>text1:</span>{{text1}}
                <span>text2:</span>{{tetx2}}
              </div>`,
    data:{
        text1:'text1',
        text2:'text2',
        text3:'text3'
    }
})

按照上面的響應式原理中的方法進行綁定則會出現一個問題--text3在實際模板中並無被用到，然而當text3的數據被修改時，一樣會觸發text3的setter致使從新執行渲染，這顯然不正確。

先說說Dep

當對data上的對象進行修改值的時候會觸發它的setter，那麼取值的時候天然會觸發getter事件，因此咱們只要在最開始進行一次render，那麼全部被渲染所依賴的data中的數據就會被getter收集到Dep的subs中去。在對data中的數據進行修改的時候setter只會觸發Dep的subs函數。
定義一個依賴收集類的Dep。

class Dep{
    constructor(){
        this.subs = [];
    }
    addSub(sub:Watcher){
        this.subs.push(sub)
    }
    removeSub(sub:Watcher){
        remove(this.subs,sub)
    }
    notify(){
        const subs = this.subs.slice()
        for(let i = 0;l=subs.length;i<1;i++){
            subs[i].update()
        }
    }
}
function remove(arr,item){
    if(arr.length){
        const index = arr.indexOf(item)
        if(index>-1){
            return arr.splice(index,1)
        }
    }
}

Watcher

訂閱者，當依賴收集的時候會addSub到sub中，在修改data中數據的時候會觸發dep對象的notify，通知全部Watcher對象去修改對應視圖。

class Watcher {
    constructor (vm, expOrFn, cb, options) {
        this.cb = cb;
        this.vm = vm;

        /*在這裏將觀察者自己賦值給全局的target，只有被target標記過的纔會進行依賴收集*/
        Dep.target = this;
        /*Github:https://github.com/answershuto*/
        /*觸發渲染操做進行依賴收集*/
        this.cb.call(this.vm);
    }

    update () {
        this.cb.call(this.vm);
    }
}

開始依賴收集

class Vue {
    constructor(options) {
        this._data = options.data;
        observer(this._data, options.render);
        let watcher = new Watcher(this, );
    }
}

function defineReactive (obj, key, val, cb) {
    /*在閉包內存儲一個Dep對象*/
    const dep = new Dep();

    Object.defineProperty(obj, key, {
        enumerable: true,
        configurable: true,
        get: ()=>{
            if (Dep.target) {
                /*Watcher對象存在全局的Dep.target中*/
                dep.addSub(Dep.target);
            }
        },
        set:newVal=> {
            /*只有以前addSub中的函數纔會觸發*/
            dep.notify();
        }
    })
}

Dep.target = null;

將觀察者Watcher實例賦值給全局的Dep.target，而後觸發render操做只有被Dep.target標記過的纔會進行依賴收集。有Dep.target的對象會將Watcher的實例push到subs中，在對象被修改觸發setter操做的時候dep會調用subs中的Watcher實例的update方法進行渲染。