class Vue{
    constructor(options){
        // 1、通過屬性保存穿進來的屬性
        this.$options= options||{};
        this.$data= options.data||{};
        this.$el = typeof options.el ==='string' ? document.querySelector(options.el) : options.el;
        // 2、把data參數(shù)中的數(shù)據(jù)轉(zhuǎn)換為getter和setter 掛載到Vue實例上
        this._proxyData(this.$data)
        // 3、調(diào)用observe對象監(jiān)視data數(shù)據(jù)的變化
        new Observer(this.$data)
        // 4、調(diào)用compiler對象渲染頁面
        new Compiler(this)
    }
    _proxyData(data){
        if (data&&Object.keys(data).length>0){
             for (const key in data) {
                Object.defineProperty(this,key,{
                    configurable:true,
                    enumerable:true,
                    get(){
                        return data[key]
                    },
                    set(value){
                        if (data[key]===value) {
                            return;
                        }
                        data[key]=value;
                    }
                })
             }
        }
    }
}

//數(shù)據(jù)劫持   class Observer {
    constructor(data) {
        this.walk(data)
    }
    walk(data) { 
        //1、判斷data是否是對象    
        if (!data || typeof data !== 'object') {     
            return
        }
        //2、循環(huán)調(diào)用defineReactive進行數(shù)據(jù)劫持
        Object.keys(data).forEach(key => {
            this.defineReactive(data, key, data[key])
        })
    }
    defineReactive(obj, key, val) {
        //創(chuàng)建通知者
        const dep = new Dep()
        //使用walk把引用對象中的屬性變成響應(yīng)式的
        this.walk(val)
        const that=this;
        Object.defineProperty(obj, key, {
            configurable: true,
            enumerable: true,
            get() {
                //通知者收集觀察者
                Dep.target && dep.addSub(Dep.target)
                return val;
            },
            set(newVal) {
                if (newVal === val) {
                    return;
                }
                val = newVal;
                that.walk(newVal)
                //被觀察者發(fā)生變化的時候，通知者對象給每個觀察者發(fā)送通知
                dep.notify()
            }
        })
    }
}

//編譯器   class Compiler {
    constructor(vm) {
        this.el = vm.$el;
        this.vm = vm;
        this.compile(this.el)
    }
    //編譯模板 判斷節(jié)點是文本節(jié)點還是元素節(jié)點
    compile(el) {
        let childNodes = el.childNodes;
        //處理第一層子節(jié)點
        Array.from(childNodes).forEach(node => {
            if (this.isTextNode(node)) {
                this.compileText(node)
            } else if (this.isElementNode(node)) {
                this.compileElement(node)
            }
            //如果當前節(jié)點還有子節(jié)點  遞歸調(diào)用編譯指令
            if (node.childNodes && node.childNodes.length) {
                this.compile(node)
            }
        })
    }

    //編譯元素節(jié)點，處理指令
    compileElement(node) {  
        //遍歷所有的指令
        Array.from(node.attributes).forEach(attr => {
            //判斷是不是指令節(jié)點
            if (this.isDirective(attr.name)) {
                const nodeName = attr.name;
                const key = attr.nodeValue;
                const directive = nodeName.substr(2)
                this.updater(directive,node,key)
            }
        }) 
    }
    updater(directive,node,key){
        const updaterFn = this[directive+"Updater"]
        updaterFn && updaterFn.call(this,node,this.vm[key],key)
    }
    //v-text
    textUpdater(node,value,key){
        node.textContent=value
        //使用v-text表達式的地方就是一個觀察者
        new Watcher(this.vm,key,newValue => {
            node.textContent = newValue
        })
    }
    //v-model
    modelUpdater(node,value,key){
        node.value =value
        //使用v-model表達式的地方就是一個觀察者
        new Watcher(this.vm,key,newValue => {
            node.value = newValue
        })
      //實現(xiàn)雙向綁定
        node.addEventListener('input',()=>{
            this.vm[key] = node.value
        })
    }
    //v-html
    htmlUpdater(node,value,key){
        node.innerHTML = value
        //使用v-html表達式的地方就是一個觀察者
        new Watcher(this.vm,key,newValue => {
            node.innerHTML = newValue
        })
    }

    //處理差值表達式
    compileText(node) {
        //匹配差值表達式的正則
        let reg = /\{\{(.+?)\}\}/
        //用正則匹配node的textContent,如果匹配到了 就替換
        if (reg.test(node.textContent)) {
            //獲取插值表達式的key
            let key = RegExp.$1;
            let value = node.textContent;
            node.textContent = value.replace(reg, this.vm[key])

            //使用差值表達式的地方就是一個觀察者
            new Watcher(this.vm,key,newValue => {
                node.textContent = newValue
            })
        }
    }

    //是否是指令
    isDirective(attrName) {
        return attrName.startsWith('v-')
    }

    //是否是文本節(jié)點
    isTextNode(node) {
        return node.nodeType === 3
    }

    //是否是元素
    isElementNode(node) {
        return node.nodeType === 1
    }
}

//通知者類   class Dep {
    constructor() {
        //存儲觀察者
        this.subs = []
    }

    /**
     * 收集觀察者
     */
    addSub(sub) {
        if (sub && sub.update) {
            this.subs.push(sub)
        }
    }

    /**
     * 通知觀察者改變狀態(tài)
     */
    notify() {
        this.subs.forEach(sub => {
            sub.update()
        })
    }
}

//觀察者類   class Watcher {
    constructor (vm,key,cb) {
        //Vue實例
        this.vm =vm;
        // data中的key對象
        this.key =key;
        // 更新視圖的回調(diào)函數(shù)
        this.cb = cb
        //把當前觀察者實例存放在Dep的target靜態(tài)屬性中
        Dep.target =this
        //觸發(fā)Observe的getter方法，把當前實例存放在Dep.subs中
        //data中key對應(yīng)的舊值
        this.oldValue = this.vm[this.key]
        Dep.target = null
    }
    //每個觀察者都有一個update方法來改變狀態(tài)
    update(){
        const newValue = this.vm[this.key]
        if ( this.newValue === this.oldValue ) {
            return
        }
        this.cb(newValue)
    }
}

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>index</title>
    <script src="./js/dep.js"></script>
    <script src="./js/watcher.js"></script>
    <script src="./js/compiler.js"></script>
    <script src="./js/observer.js"></script>
    <script src="./js/vue.js"></script>
</head>
<body>
    <p id="app">
        <h1>差值表達式</h1>
        <h3>{{msg}}</h3>
        <h3>{{count}}</h3>
        <h1>v-text</h1>
        <p v-text='msg'></p>
        <h1>v-model</h1>
        <input type="text" v-model="msg" attr="msg">
        <input type="text" v-model="count">
        <h1>v-html</h1>
        <p v-html="htmlText"></p>
    </p>
    <script>
        let vm = new Vue({
            el:"#app",
            data:{
                msg:'信息',
                count:'數(shù)量', 
		person:{name:'張三'},
                htmlText:"<p style='color:red'>你好</p>"
            }
        })
    </script>
</body>