简单模拟Vue中v-model底层（碎片化文档+发布、订阅者模式）

实现原理

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

实现步骤：

第一步： 需要observe的数据对象进行递归遍历，包括子属性对象的属性，都加上 setter和getter这样的话，给这个对象的某个值赋值，就会触发setter，那么就能监听到了数据变化

第二步： compile解析模板指令，将模板中的变量替换成数据，然后初始化渲染页面视图，并将每个指令对应的节点绑定更新函数，添加监听数据的订阅者，一旦数据有变动，收到通知，更新视图

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

第四步： MVVM作为数据绑定的入口，整合Observer、Compile和Watcher三者，通过Observer来监听自己的model数据变化，通过Compile来解析编译模板指令，最终利用Watcher搭起Observer和Compile之间的通信桥梁，达到数据变化 -> 视图更新；视图交互变化(input) -> 数据model变更的双向绑定效果。

代码的实现

<div id="app">
    <input type="text" v-model="msg">
    <input type="text" v-model="msg">
    <input type="text" v-model="msg">
    {{ msg }}
</div>

<script>
    //优先考虑的问题
    //1、如何将数据绑定在input表单上
    //2、input输入的数据如何绑定到文本元素上

    //定义一个编译函数
    function compile(node, vm) {
        //定义一个正则 获取{{abc}} 里面的abc
        var reg = /\{\{(.*)\}\}/

        if (node.nodeType == 1) {
            var attr = node.attributes  //获取到指定节点的属性集合
            console.log(attr)
            for (let i = 0; i < attr.length; i++) {
                if (attr[i].nodeName == "v-model") {  //nodeName节点名称
                    console.log(attr[i].nodeName)  //v-model
                    var name = attr[i].nodeValue  //msg
                    node.value = vm.data[name]  //将vm实例中的data中的name属性值赋值给节点
                    node.addEventListener("input", function (e) {
                        console.log(e.target.value)
                        vm[name] = e.target.value
                    })
                    node.value = vm.data[name]
                    // node.removeAttribute("v-model")
                    new WatchFn(vm, node, name)
                }
            }
        }

        if (node.nodeType == 3) {  //文本节点
            if (reg.test(node.nodeValue)) {
                console.log(RegExp.$1)  //msg
                var name = RegExp.$1
                name = name.trim()  //过滤开始和结束的空格
                console.log(vm.data[name])
                //node.nodeValue = vm.data[name]
                //订阅者
                new WatchFn(vm, node, name)
            }
        }
        //nodeType=1  元素节点
        //nodeType=2  属性节点 
        //nodeType=3  文本节点

    }

    //定义一个碎片化文档容器，来存节点
    function nodeFragment(node, vm) {
        var fragment = document.createDocumentFragment()  //创建一个收纳DOM节点的容器
        var child;
        while (child = node.firstChild) {
            compile(child, vm)  //执行编译函数
            fragment.appendChild(child)
        }
        return fragment
    }


    //实现view到model层的数据更新
    //1、给输入框添加一个事件获取输入的值
    //2、通过Object.difineProperty(),监听所有属性的变化

    function defineFn(obj, key, val) {
        var zhuti = new Zhuti()
        console.log(zhuti)
        Object.defineProperty(obj, key, {
            get: function () {
                if (Zhuti.target) {
                    zhuti.addSub(Zhuti.target)
                }
                return val
            },
            set: function (newVal) {
                if (val == newVal) {
                    return;
                }
                val = newVal
                console.log(val)
                //执行一个主题通知
                zhuti.notify() //立即通知更新
            }
        })
    }


    //定义一个观察着,观察每个属性的变化
    function observer(obj, vm) {
        for (let key of Object.keys(obj)) {
            console.log(key)
            defineFn(vm, key, obj[key])
        }
    }

    //定义一个主题对象
    function Zhuti() {
        this.subs = []  //存放的是订阅者
    }
    Zhuti.prototype = {
        addSub(sub) {
            this.subs.push(sub)
        },
        notify() {
            console.log(111111111111111)
            this.subs.forEach(function (sub) {
                sub.update()
            })
        }
    }

    //定义一个订阅者
    function WatchFn(vm, node, name) {
        Zhuti.target = this  //Zhuti.target 是一个全局的变量
        this.vm = vm;
        this.node = node
        this.name = name
        this.update()
        console.log(this)
        Zhuti.target = null
    }

    WatchFn.prototype = {
        update() {
            this.get()
            if (this.node.nodeType == 1) {
                this.node.value = this.value
            } else if (this.node.nodeType == 3) {
                this.node.nodeValue = this.value
            }

        },
        get() {
            this.value = this.vm[this.name]
        }
    }

    //定义一个构造函数
    function Vue(json) {
        this.data = json.data
        var id = json.el.slice(1)
        observer(this.data, this)  //执行观察者
        var dom = nodeFragment(document.getElementById(id), this)
        console.log(dom)

        document.getElementById(id).appendChild(dom)  //整体放在浏览器的指定盒子中，回流一次
    }

    var vm = new Vue({
        el: "#app",
        data: {
            msg: "abc",
            text: "llr"
        }
    })
    console.log(vm)
</script>