阅读 94

深入理解Vue响应式原理笔记

Vue2的响应式是通过数据劫持(Object.defineProperty)和发布-订阅模式完成的。 比较核心的几块内容是Observer、Watcher、Compile以及Dep这4个概念。

20190905003007583.jpg

介绍一下总体的流程:每当new一个Vue,主要做两件事: 第一监听数据:observer(data); 第二编译HTML:nodeToFragement(id)。

在监听数据的过程中,会为data中的每一个属性生成一个dep容器(可观察对象)。

在编译HTML的过程中,会为每一个与数据绑定相关的节点生产一个订阅者watcher,watcher会将自己添加到dep相应的属性(subs)中,例如当我们修改输入框的内容时 =>修改属性值 =>触发了该属性的set方法。

属性的set方法中会执行dep.notify(),通知所有的订阅者(watcher)执行uptade方法,更新视图。

Observer 观察者

通过Object.defineProperty, 负责监听data的变化,有变化时,通知发布者改变页面内容。

var data = {name: 'kindeng'};
observe(data);
data.name = 'dmq'; // 哈哈哈,监听到值变化了 kindeng --> dmq

function observe(data) {
    if (!data || typeof data !== 'object') {
        return;
    }
    // 取出所有属性遍历
    Object.keys(data).forEach(function(key) {
        defineReactive(data, key, data[key]);
    });
};

function defineReactive(data, key, val) {
    observe(val); // 监听子属性
    Object.defineProperty(data, key, {
        enumerable: true, // 可枚举
        configurable: false, // 不能再define
        get: function() {
            return val;
        },
        set: function(newVal) {
            console.log('哈哈哈,监听到值变化了 ', val, ' --> ', newVal);
            val = newVal;
        }
    });
}
复制代码

这样我们已经可以监听每个数据的变化了,那么监听到变化之后就是怎么通知订阅者了,所以接下来我们需要实现一个消息订阅器,很简单,维护一个数组,用来收集订阅者,数据变动触发notify,再调用订阅者的update方法,代码改善之后是这样:

// ... 省略
function defineReactive(data, key, val) {
    var dep = new Dep(); //data中每一个数据对应一个Dep容器,存放所有依赖于该数据的依赖项
    observe(val); // 监听子属性

    Object.defineProperty(data, key, {
        // ... 省略
        get() {
                if (Dep.target) {//Dep.target存放具体的依赖,在编译阶段检测到依赖后被赋值
                    dep.addDep(Dep.target); //依赖收集
                }
                return val;
        },
        set: function(newVal) {
            if (val === newVal) return;
            console.log('哈哈哈,监听到值变化了 ', val, ' --> ', newVal);
            val = newVal;
            dep.notify(); // 通知所有订阅者 //当数据发生变化时,通知所有的依赖进行更新显示
        }
    });
}

//Dep容器,data中的每个数据会对应一个,用来收集并存储依赖
function Dep() {
    this.subs = []; //所有的依赖将存放在该数组中
}
Dep.prototype = {
    addSub: function(sub) {
        this.subs.push(sub); //收集依赖/订阅者
    },
    notify: function() {
        this.subs.forEach(function(sub) {
            sub.update();
        });
    }
};
复制代码

那么问题来了,谁是订阅者?怎么往订阅器添加订阅者? 没错,上面的思路整理中我们已经明确订阅者应该是Watcher, 而且var dep = new Dep();是在 defineReactive方法内部定义的,所以想通过dep添加订阅者,就必须要在闭包内操作,所以我们可以在 getter里面动手脚:

// Observer.js
// ...省略
Object.defineProperty(data, key, {
    get: function() {
        // 由于需要在闭包内添加watcher,所以通过Dep定义一个全局target属性,暂存watcher, 添加完移除
        Dep.target && dep.addSub(Dep.target);
        return val;
    }
    // ... 省略
});

// Watcher.js
Watcher.prototype = {
    get: function(key) {
        Dep.target = this;
        this.value = data[key];    // 这里会触发属性的getter,从而添加订阅者
        Dep.target = null;
    }
}
复制代码

watcher 订阅者

Watcher订阅者作为Observer和Compile之间通信的桥梁,主要做的事情是: 1、在自身实例化时往属性订阅器(dep)里面添加自己 2、自身必须有一个update()方法 3、待属性变动dep.notice()通知时,能调用自身的update()方法,并触发Compile中绑定的回调,则功成身退。

function Watcher(vm, exp, cb) {
    this.cb = cb;
    this.vm = vm;
    this.exp = exp;
    // 此处为了触发属性的getter,从而在dep添加自己,结合Observer更易理解
    this.value = this.get(); 
}
Watcher.prototype = {
    update: function() {
        this.run();    // 属性值变化收到通知
    },
    run: function() {
        var value = this.get(); // 取到最新值
        var oldVal = this.value;
        if (value !== oldVal) {
            this.value = value;
            this.cb.call(this.vm, value, oldVal); // 执行Compile中绑定的回调,更新视图
        }
    },
    get: function() {
        Dep.target = this;    // 将当前订阅者指向自己
        var value = this.vm[exp];    // 触发getter,添加自己到属性订阅器中
        Dep.target = null;    // 添加完毕,重置
        return value;
    }
};
// 这里再次列出Observer和Dep,方便理解
Object.defineProperty(data, key, {
    get: function() {
        // 由于需要在闭包内添加watcher,所以可以在Dep定义一个全局target属性,暂存watcher, 添加完移除
        //最后将Dep.target设置为空。 因为他是全局变量,也是watcher和dep关联的唯一桥梁,任何时候,都必须保证Dep.target只有一个值。
        Dep.target && dep.addDep(Dep.target);  //依赖收集
        return val;
    }
    // ... 省略
     set: function(newVal) {
            if (val === newVal) return;
            console.log('哈哈哈,监听到值变化了 ', val, ' --> ', newVal);
            val = newVal;
            dep.notify(); // 通知所有订阅者 //当数据发生变化时,通知所有的依赖进行更新显示
        }
});

Dep.prototype = {
    notify: function() {
        this.subs.forEach(function(sub) {
            sub.update(); // 调用订阅者的update方法,通知变化
        });
    }
};
复制代码

实例化Watcher的时候,调用get()方法,通过Dep.target = watcherInstance标记订阅者是当前watcher实例,强行触发属性定义的getter方法,getter方法执行的时候,就会在属性的订阅器dep添加当前watcher实例,从而在属性值有变化的时候,watcherInstance就能收到更新通知。

Compiler 模板解析器

模板解析器compile主要做的事情是解析模板指令,将模板中的变量替换成数据,然后初始化渲染页面视图,并将每个指令对应的节点绑定更新函数,添加监听数据的订阅者,一旦数据有变动,收到通知,更新视图 compileElement方法将遍历所有节点及其子节点,进行扫描解析编译,调用对应的指令渲染函数进行数据渲染,并调用对应的指令更新函数进行绑定,详看代码及注释说明:

Compile.prototype = {
    // ... 省略
    compileElement: function(el) {
        var childNodes = el.childNodes, me = this;
        [].slice.call(childNodes).forEach(function(node) {
            var text = node.textContent;
            var reg = /\{\{(.*)\}\}/;    // 表达式文本
            // 按元素节点方式编译
            if (me.isElementNode(node)) {
                me.compile(node);
            } else if (me.isTextNode(node) && reg.test(text)) {
                me.compileText(node, RegExp.$1);
            }
            // 遍历编译子节点
            if (node.childNodes && node.childNodes.length) {
                me.compileElement(node);
            }
        });
    },

    compile: function(node) {
        var nodeAttrs = node.attributes, me = this;
        [].slice.call(nodeAttrs).forEach(function(attr) {
            // 规定:指令以 v-xxx 命名
            // 如 <span v-text="content"></span> 中指令为 v-text
            var attrName = attr.name;    // v-text
            if (me.isDirective(attrName)) {
                var exp = attr.value; // content
                var dir = attrName.substring(2);    // text
                if (me.isEventDirective(dir)) {
                    // 事件指令, 如 v-on:click
                    compileUtil.eventHandler(node, me.$vm, exp, dir);
                } else {
                    // 普通指令
                    compileUtil[dir] && compileUtil[dir](node, me.$vm, exp);
                }
            }
        });
    }
};

// 指令处理集合
var compileUtil = {
    text: function(node, vm, exp) {
        this.bind(node, vm, exp, 'text');
    },
    // ...省略
    bind: function(node, vm, exp, dir) {
        var updaterFn = updater[dir + 'Updater'];
        // 第一次初始化视图
        updaterFn && updaterFn(node, vm[exp]);
        // 实例化订阅者,此操作会在对应的属性消息订阅器中添加了该订阅者watcher
        new Watcher(vm, exp, function(value, oldValue) {
            // 一旦属性值有变化,会收到通知执行此更新函数,更新视图
            updaterFn && updaterFn(node, value, oldValue);
        });
    }
};

// 更新函数
var updater = {
    textUpdater: function(node, value) {
        node.textContent = typeof value == 'undefined' ? '' : value;
    }
    // ...省略
};
复制代码

关键点实现

如何将watcher添加到关联的dep容器中。

1、如何将watcher添加到关联的dep容器中。

watcher在执行update时会调用自身的get方法,使Dep的静态属性target指向自身Dep.target = this,紧接着执行var value = this.vm[exp] 触发属性的getter,即把自己添加到属性订阅器subs中,dep.addDep(Dep.target),特别注意一点,执行完毕后将Dep.target属性置为null,因为它是一个全局变量,也是wather和dep关联的唯一桥梁。

export default class Dep {
 addSub (sub: Watcher) {
    this.subs.push(sub)
  }
  notify () {
    // stabilize the subscriber list first
    const subs = this.subs.slice()
    for (let i = 0, l = subs.length; i < l; i++) {
      subs[i].update()
    }
  }
}
复制代码

很多内容都是借鉴别人的,这里只是用来记录,自己复习看,勿喷谢谢~

终极流程图

reactive.png

参考资料

  1. 重点源码分析,observer、dep、compiler、watcher等 segmentfault.com/a/119000001…
  2. 依赖收集(讲解Dep和Watcher的关系) www.cnblogs.com/samwu/p/123…
  3. 好的文章1,其实看这篇文章就够了,比下面那篇更清楚 www.jianshu.com/p/d723f3dc4…
  4. 好的文章2 segmentfault.com/a/119000000…
  5. 究极之更好的文章 blog.csdn.net/huolinianyu…
文章分类
前端
文章标签