vue双向数据绑定原理及实现

最新推荐文章于 2023-07-28 15:24:35 发布

茉莉蜜茶~~~

最新推荐文章于 2023-07-28 15:24:35 发布

阅读量458

点赞数 4

分类专栏： vue

本文链接：https://blog.csdn.net/weixin_42038290/article/details/114921661

版权

vue 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

现在，vue已经成为了前端开发者必会的一个框架了，但是，对于里面的双向绑定原理只是了解了个大概，并没有很深入的去探究其原理的的实现，所以，最近，特意话了一段时间来深入的研究了下，并实现了个简单版的vue双向绑定

vue数据双向绑定原理

vue.js 则是采用数据劫持结合发布者-订阅者模式的方式，通过Object.defineProperty()来劫持各个属性的setter，getter，在数据变动时发布消息给订阅者，触发相应的监听回调。

实现过程

我们已经知道实现数据的双向绑定，首先要对数据进行劫持监听，所以我们需要设置一个监听器Observer，用来监听所有属性。如果属性发上变化了，就需要告诉订阅者Watcher看是否需要更新。因为订阅者是有很多个，所以我们需要有一个消息订阅器Dep来专门收集这些订阅者，然后在监听器Observer和订阅者Watcher之间进行统一管理的。接着，我们还需要有一个指令解析器Compile，对每个节点元素进行扫描和解析，将相关指令对应初始化成一个订阅者Watcher，并替换模板数据或者绑定相应的函数，此时当订阅者Watcher接收到相应属性的变化，就会执行对应的更新函数，从而更新视图。因此接下去我们执行以下4个步骤，实现数据的双向绑定：

实现一个监听器Observer，用来劫持并监听所有属性，如果有变动的，就通知订阅者。
实现一个订阅者Watcher，可以收到属性的变化通知并执行相应的函数，从而更新视图。
实现一个解析器Compile，对每个元素节点的指令进行扫描和解析，根据指令模板替换数据，以及绑定相应的更新函数
mvvm入口函数，整合以上三者

流程图如下：
在这里插入图片描述

1.实现一个Observer

Observer是一个数据监听器，其实现核心方法就是前文所说的Object.defineProperty( )。如果要对所有属性都进行监听的话，那么可以通过递归方法遍历所有属性值，并对其进行Object.defineProperty( )处理。如下代码，实现了一个Observer。

class Observer{
    constructor(data){
        this.walk(data)
    }
    //对传入的数据进行劫持
    walk(data){
    	 //判断是否是对象，如果不是，则返回
        if(!data || typeof data !=='object'){
            return;
        }
        for(let key in data){
            this.defineReactive(data,key,data[key])
        }
    }
    defineReactive(obj,key,value){
        new Observer(value);// 递归遍历所有子属性
        Object.defineProperty(obj,key,{
            configurable:true,
            enumerable:true,
            get:function(){
                return value
            },
            set:function(newValue){
                if(value === newValue){
                    return;
                }
                value = newValue
            }
        })
    }
}

var library = {
    book1: {
        name: ''
    },
    book2: ''
};
observe = new Observer(library);
library.book1.name = 'vue权威指南'; // 属性name已经被监听了，现在值为：“vue权威指南”
library.book2 = '没有此书籍';  // 属性book2已经被监听了，现在值为：“没有此书籍”

思路分析中，需要创建一个可以容纳订阅者的消息订阅器Dep，订阅器Dep主要负责收集订阅者，然后再属性变化的时候执行对应订阅者的更新函数。所以显然订阅器需要有一个容器，这个容器就是list，将上面的Observer稍微改造下，植入消息订阅器：

class Dep{
    constructor(){
        this.subs = []
    }
    //添加进订阅器容器
    addSubs(sub){
        if (sub && sub.update && this.subs.indexOf(sub) < 0) {
            this.subs.push(sub);
        }
    }
    //通知所有订阅者
    notify(){
        if(this.subs.length>0){
            this.subs.forEach((sub)=>{
                sub.update()
            })
        }
    }
}
...此处省略
defineReactive(obj,key,value){
    const dep = new Dep() // 创建当前属性的发布者
    new Observer(value);// 递归遍历所有子属性
    Object.defineProperty(obj,key,{
        configurable:true,
        enumerable:true,
        get:function(){
             if (是否需要添加订阅者) {
                dep.addSub(watcher); // 在这里添加一个订阅者
            }
            return value
        },
        set:function(newValue){
              if (value === newValue) {
                return;
            }
            value === newValue
            console.log('属性' + key + '已经被监听了，现在值为：“' + newValue.toString() + '”');
            dep.notify()
        }
    })
}

从代码上看，我们将订阅器Dep添加一个订阅者设计在getter里面，这是为了让Watcher初始化进行触发，因此需要判断是否要添加订阅者，至于具体设计方案，下文会详细说明的。在setter函数里面，如果数据变化，就会去通知所有订阅者，订阅者们就会去执行对应的更新的函数。到此为止，一个比较完整Observer已经实现了，接下来我们开始设计Watcher。

2.实现Watcher

订阅者Watcher在初始化的时候需要将自己添加进订阅器Dep中，那该如何添加呢？我们已经知道监听器Observer是在get函数执行了添加订阅者Wather的操作的，所以我们只要在订阅者Watcher初始化的时候触发对应的get函数去执行添加订阅者操作即可，那要如何触发get的函数，再简单不过了，只要获取对应的属性值就可以触发了，核心原因就是因为我们使用了Object.defineProperty( )进行数据监听。这里还有一个细节点需要处理，我们只要在订阅者Watcher初始化的时候才需要添加订阅者，所以需要做一个判断操作，因此可以在订阅器上做一下手脚：在Dep.target上缓存下订阅者，添加成功后再将其去掉就可以了。订阅者Watcher的实现如下：

class Watcher{
    constructor(vm,key,updateCb){
       this.vm = vm
        this.key = key
        this.updateCb = updateCb
        Dep.target = this
        this.oldValue = vm[key]
        Dep.target = null;
    }
    update() {
      const newValue = this.vm[this.key];
        if (this.oldValue !== newValue) {
            this.updateCb(newValue);
        } 
    }
}

这时候，我们需要对监听器Observer也做个稍微调整，主要是对应Watcher类原型上的get函数。需要调整地方在于defineReactive函数：

    defineReactive(obj,key,value){
        const dep = new Dep()
        new Observer(value);
        Object.defineProperty(obj,key,{
            configurable:true,
            enumerable:true,
            get:function(){
                // 若当前有对该属性的依赖项，则将其加入到发布者的订阅者队列里
               if(Dep.target){
                    dep.addSub(Dep.target)
                }
                return value
            },
            set:function(newValue){
                if(value === newValue){
                    return;
                }
                value = newValue
                new Observer(value) //递归检测
                dep.notify()
            }
        })
    }

到此为止，简单版的Watcher设计完毕，这时候我们只要将Observer和Watcher关联起来，就可以实现一个简单的双向绑定数据了。因为这里没有还没有设计解析器Compile，所以对于模板数据我们都进行写死处理，假设模板上又一个节点，且id号为’name’，并且双向绑定的绑定的变量也为’name’，且是通过两个大双括号包起来（这里只是为了演示，暂时没什么用处），模板如下：

<body>
    <h1 id="name">{{name}}</h1>
</body>

这时候我们需要将Observer和Watcher关联起来：

class selfVue{
    constructor(opations,el,key){
        this.data = opations.data;
        this.el  = el 
        this.key= key
        this.init(t)
    }
    init(){
        new Observer(this.data);
        this.el.innerHTML = this.data[this.key];  // 初始化模板数据的值
        new Watcher(this,this.key,(newValue)=> {
            this.el.innerHTML = newValue
        });
    }
}

var el = document.querySelector('#name');
var selfVue= new selfVue({
    data:{name: 'hello world'}
}, el, 'name');

window.setTimeout(function () {
    console.log('name值改变了');
    selfVue.data.name = 'hi';
}, 2000);

这时候打开页面，可以看到页面刚开始显示了是’hello world’，过了2s后就变成’hi’了。到这里，总算大功告成一半了，但是还有一个细节问题，我们在赋值的时候是这样的形式 ’ selfVue.data.name = ‘hi’ ’ 而我们理想的形式是’ selfVue.name = ‘hi’ '为了实现这样的形式，我们需要在new SelfVue的时候做一个代理处理，让访问selfVue的属性代理为访问selfVue.data的属性，实现原理还是使用Object.defineProperty( )对属性值再包一层：

class SelfVue{
    constructor(opations,el,key){
        this.data = opations.data;
        this.el  = el 
        this.key = key
        this.init()
    }
    init(){
        Object.keys(this.data).forEach(key=>{
            this.proxyKeys(key);  // 绑定代理属性
        });
        new Observer(this.data);
        this.el.innerHTML = this.data[this.key];  // 初始化模板数据的值
        new Watcher(this,this.key,(oldValue,newValue)=> {
            this.el.innerHTML = newValue
        });
    }
    proxyKeys(key){
        Object.defineProperty(this, key, {
            enumerable: false,
            configurable: true,
            get: function proxyGetter() {
                return this.data[key];
            },
            set: function proxySetter(newVal) {
                this.data[key] = newVal;
            }
        });
    }
}

这下我们就可以直接通过’ selfVue.name = ‘hi’ '的形式来进行改变模板数据了

3.实现Compile

compile主要做的事情是解析模板指令，将模板中的变量替换成数据，然后初始化渲染页面视图，并将每个指令对应的节点绑定更新函数，添加监听数据的订阅者，一旦数据有变动，收到通知，更新视图，如图所示：
在这里插入图片描述
因为遍历解析的过程有多次操作dom节点，为提高性能和效率，会先将跟节点el转换成文档碎片fragment进行解析编译操作，解析完成，再将fragment添加回原来的真实dom节点中

class Compile {
    constructor(vm){
        this.vm = vm
        this.el = this.vm.$el
        this.methods = this.vm.$methods
        this.fragment = this.nodeToFragment(this.el);
        this.compile(this.fragment);
        this.el.appendChild(this.fragment)
    }
    //因为dom操作比较频繁，所有可以先建一个fragment片段，将需要解析的dom节点存入fragment片段里再进行处理：
    nodeToFragment(el){
        var fragment = document.createDocumentFragment();
        var child = el.firstChild
        // 将原生节点拷贝到fragment
        while (child) {
            fragment.appendChild(child);
            child = el.firstChild
        }
        return fragment;
    }
}

compileElement方法将遍历所有节点及其子节点，进行扫描解析编译，调用对应的指令渲染函数进行数据渲染，并调用对应的指令更新函数进行绑定，详看代码及注释说明：

....省略
//遍历所有节点及其子节点，进行扫描解析编译，调用对应的指令渲染函数进行数据渲染，并调用对应的指令更新函数进行绑定
  compile(el) {
        var childNodes = el.childNodes;
        [].slice.call(childNodes).forEach((node)=>{
            var text = node.textContent;
            var reg = /\{\{(.*)\}\}/;    // 表达式文本
            // 按元素节点方式编译
            if (this.isElementNode(node)) {
                this.compileElement(node);
            } else if (this.isTextNode(node) && reg.test(text)) { //文本节点
                this.compileText(node, RegExp.$1);
            }
            // 遍历编译子节点
            if (node.childNodes && node.childNodes.length) {
                this.compile(node);
            }
        });
    }
    compileElement(node) {
        var nodeAttrs = node.attributes;
        [].slice.call(nodeAttrs).forEach((attr)=> {
            // 规定：指令以 v-xxx 命名
            // 如 <span v-text="content"></span> 中指令为 v-text
            var attrName = attr.name;    // v-text

            if (this.isDirective(attrName)) {
                var value = attr.value; // content
                var key = attrName.substring(2);    // text
                if (this.isEventDirective(key)) {
                    // 事件指令, 如 v-on:click
                    this.compileEvent(node,this.vm,value,key);
                } else {
                    // 普通指令 v-model
                    this.compileModel(node,this.vm,value,key);
                }
                node.removeAttribute(attrName);
            }
        });
    }
   //执行{{}}的节点的值
    compileText (node, key) { //每个符合{{}}的节点，{{}}里面的内容值
        var value = this.vm[key];
        this.updateText(node, value);  // 将初始化的数据初始化到视图中
        new Watcher(this.vm, key, (newValue)=> {  // 生成订阅器并绑定更新函数
            this.updateText(node, newValue);
        });
    }
    //执行事件的节点的值
    compileEvent (node,vm,value,key) {
        var eventType = key.split(':')[1];
        var cb = this.methods && this.methods[value];
        if (eventType && cb) {
            node.addEventListener(eventType, cb.bind(vm), false);
        }
    }
   //执行模块的节点的值
    compileModel(node,vm,key) {
        var val = vm[key];
        this.modelUpdater(node, val);
        new Watcher(vm,key,(newValue)=> {
            this.modelUpdater(node, newValue);
        });

        node.addEventListener('input',(e)=> {
            var newValue = e.target.value;
            if (val === newValue) {
                return;
            }
            vm[key] = newValue;
            val = newValue;
        });
    }
   //更新文本
    updateText (node, value) {
        node.textContent = typeof value == 'undefined' ? '' : value;
    }
    //更新模块
    modelUpdater(node, value, oldValue) {
        node.value = typeof value == 'undefined' ? '' : value;
    }

最后我们在创造类SelfVue

class SelfVue {
    constructor(options){
        this.options = options
        this.data = options.data;
        this.$el = typeof options.el == 'string'?document.querySelector(options.el):options.el
        this.$methods = options.methods;
        this.init(this.$data)
    };
    init(data){
        Object.keys(data).forEach(key=>{
            this.proxyKeys(key);  // 绑定代理属性
        });
        new Observer(data);
        new Compile(this);
        this.options.mounted.call(this); // 所有事情处理好后执行mounted函数
    }
    proxyKeys(key){
        Object.defineProperty(this, key, {
            enumerable: false,
            configurable: true,
            get() {
                return this.$data[key];
            },
            set(newVal) {
                if(this.data[key] === newVal){
                    return;
                }
                this.data[key] = newVal;
            }
        });
    }   
}

这时候我们可以来真正测试了，在页面上设置如下东西：

<body>
    <div id="app">
        <h2>{{title}}</h2>
        <input v-model="name">
        <h1>{{name}}</h1>
        <button v-on:click="clickMe">click me!</button>
    </div>
</body>
<script src="js/observer.js"></script>
<script src="js/watcher.js"></script>
<script src="js/compile.js"></script>
<script type="text/javascript">
 
     new SelfVue({
        el: '#app',
        data: {
            title: 'hello world',
            name: 'canfoo'
        },
        methods: {
            clickMe: function () {
                this.title = 'hello world';
            }
        },
        mounted: function () {
            window.setTimeout(() => {
                this.title = '你好';
            }, 1000);
        }
    });
 
</script>

这时，我们就大功告成了～

源码请下载：https://github.com/yanlitingjy/vue-model

总结

本文主要围绕“几种实现双向绑定的做法”、“实现Observer”、“实现Compile”、“实现Watcher”、“实现MVVM”这几个模块来阐述了双向绑定的原理和实现。并根据思路流程渐进梳理讲解了一些细节思路和比较关键的内容点，以及通过展示部分关键代码讲述了怎样一步步实现一个双向绑定MVVM。文中不够严谨的思考和错误，欢迎大家指正，有兴趣欢迎一起探讨和改进~

茉莉蜜茶~~~

关注

4
点赞
踩
5

收藏

觉得还不错? 一键收藏
5
评论
vue双向数据绑定原理及实现

现在，vue已经成为了前端开发者必会的一个框架了，但是，对于里面的双向绑定原理只是了解了个大概，并没有很深入的去探究其原理的的实现，所以，最近，特意话了一段时间来深入的研究了下，并实现了个简单版的vue双向绑定vue数据双向绑定原理vue数据双向绑定是通过数据劫持结合发布者-订阅者模式的方式来实现的，我们可以先来看一下通过控制台输出一个定义在vue初始化数据上的对象是个什么东西。var vm = new Vue({ data: { obj: { a:.
复制链接

扫一扫

专栏目录