在Vue中,使用了Object.defineProterty()这个函数来实现双向绑定，这也就是为什么Vue不兼容IE8。我通过一个大佬的github来学习vue的源码https://github.com/answershuto/learnVue。

1 响应式原理

让我们先从相应式原理开始。我们可以通过Object.defineProterty()来自定义Object的getter和setter 从而达到我们的目的。代码如下

function observe(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: ()=>{
            /*....依赖收集等....*/
            /*Github:https://github.com/answershuto*/
            return val
        },
        set:newVal=> {
            val = newVal;
            cb();/*订阅者收到消息的回调*/
        }
    })
}

class Vue {
    constructor(options) {
        this._data = options.data;
        observe(this._data, options.render)
    }
}

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

通过observe函数对app.data上的每一个key和value都设定getter和setter。当value改变的时候触发setter,就会触发render这个函数。响应式的目的就达成
但是现在我们只有在改变vue._data.text的时候才会触发他们的setter,但是我想偷懒,只改变vue.text就能触发到setter怎么做呢？

我们使用代理的方法

_proxy.call(this, options.data);/*构造函数中*/

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

2 依赖收集

让我们再来看看下面的代码

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

当你的text3变化的时候,实际上text3并没有被渲染,但是也会触发一次render函数,这显然是不对的。所以我们需要收集依赖。
我们只需要在初始化的时候渲染一遍,那所有渲染所依赖的数据都会被触发getter,这时候我们只要把这个数据放到一个列表里就好啦！

我们先来认识一下Dep（dependencies）这个类，下图是一个最简单的Dep类。我们可以把他理解为发布者（这点很重要！！）

class Dep {
    constructor () {
        this.subs = [];
    }

    addSub (sub: Watcher) {
        this.subs.push(sub)
    }

    removeSub (sub: Watcher) {
        remove(this.subs, sub)
    }
    /*Github:https://github.com/answershuto*/
    notify () {
        // stabilize the subscriber list first
        const subs = this.subs.slice()
        for (let i = 0, l = subs.length; i < l; i++) {
            subs[i].update()
        }
    }
}
function remove (arr, item) {
    if (arr.length) {
        const index = arr.indexOf(item)
        if (index > -1) {
            return arr.splice(index, 1)
    }
}

我们每次触发getter的时候,只要把触发的对象放到dep.sub里面就好啦！
但是现在问题来了,我们用什么来装这个触发的'对象',也可以说式订阅者呢?

我们使用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);
    }
}

vm即是vue实例, expOrFn就是{{a+b}}里面的a+b, cb就是回调函数就是return a+b, options是一些配置项。
Vue在第一次渲染列表的时候如果碰到{{xxx}}这样的表达式,就会new Watcher()。解析里面的函数,然后把当前的watcher实例赋给Dep.target（Dep.target是全局的,一次性只能有一个存在,因为Vue一次只处理一个依赖）。然后执行回调函数。（这里看似是执行回调函数渲染,其实又触发了一次getter,然后就会把当前的依赖添加到sub里去）

接下来开始依赖收集

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; //防止依赖重复添加

只是这样讲大家可能还不是特别理解,让我们来看一个例子

<template>
  <div>
    {{a+b}}
  </div>
  <div>
    {{a-c}}
  </div>
</template>

<script>
let app = new Vue( {
  data :{
      a: 1,
      b: 2,
      c: 3
    }
  })

首先Vue在初始化时遍历data里所有的属性,这样每一个属性都会有属于自己的一个Dep实例(dep)，当compiler碰到{{a+b}}的时候开始渲染它,new 了一个Watcher()。watcher实例会解析 a+b并触发他们的getter, 此时在 new Watcher()的时候已经Dep.target = this。所以这个watcher会被分别加入到 a和b的dep.sub中。大家可以想象成:a.dep.sub: [{a+b}];b.dep.sub: [{a+b}]，当a和b的值改变的时候会触发他们的setter,通知dep.sub里的每一个watcher改变自己的状态！

现在大家都明白了吧。其实vue的源码也只是使用了这样的一种思想,剩余的只是在上面添枝加叶,处理各种情况。我们把上述这种思想叫做观察者模式,也叫做发布订阅者模式。
当多个对象依赖于一个属性且我们不知道具体有多少个对象存在的时候,就可以使用观察者模式。

---

为什么vue要求在对data中的数组添加删除数据时使用自带的set? 因为你push进去的数据根本没有经过数据初始化,也就不是响应式数据。。 所以Vue自己重写了一个set方法,让你push进的数据也成为响应式数据。