摘要：一起來實現一個框架最近手癢，當然也是為了近階段的跳槽做準備，利用周五時光，仿照用法，實現一下的雙向綁定數據代理大胡子模板指令，等。

最近手癢，當然也是為了近階段的跳槽做準備，利用周五時光，仿照vue用法，實現一下mvvm的雙向綁定、數據代理、大胡子{{}}模板、指令v-on，v-bind等。當然由于時間緊迫，里面的編碼細節沒有做優化，還請各位看官多多包涵！看招：

數據的劫持觀察（observe）

觀察者模式（watcher）

使用es6的類class實現（當然，沒有考慮到兼容性，只是為了實現而已）

數據劫持

_observe(obj){
        // 遞歸遍歷
        // let value;
        for (const key in obj) {
          let value;
          if (obj.hasOwnProperty(key)){
            // 利用原理 劫持數據---發布訂閱

            value = obj[key];
            if (typeof value === "object") {
              console.log("value", value)
              this._observe(value)
            }

            // 訂閱(key)數據
            if (!this._binding[key]) {this._binding[key]= []};
            let binding = this._binding[key]
            // 重寫getter, setter
            Object.defineProperty(obj, key, {
              enumerable: true,
              configurable: true,
              get() {
                return value
              },
              set(newVal) {
                if (value === newVal) return false;
                value = newVal
                console.log("newvalue", value)
                // 主要value更新，就發布通知(監聽這個key的所有的)watcher更新（改變dom）
                binding.forEach(watcher => {
                  console.log("watcher", watcher)
                  watcher.update()
                });
              }
            })
          }
        }
      }

實例代理數據

_proxyData(data, vm) {
        // data身上的所有屬性全部掛載到vm實例上
        for (const key in data) {
          // let val = data[key];
          // ctx.key = val;
          Object.defineProperty(vm, key, {
            configurable: true,
            enumerable: true,
            get() {
              return data[key];
            },
            set(newVal) {
              data[key] = newVal;
              vm._observe(newVal)
            }
          })
        }
      }

模板編譯，添加發布訂閱

_compile(root){
        // 獲取所有節點
        let nodes = root.childNodes
        
        // 遞歸編譯
        Array.from(nodes).forEach(node => {
          // 針對每一個節點進行處理

          // 元素節點
          if (node.nodeType === 1) {//只考慮綁定了一個指令
            // 獲取節點的屬性集合
            
            const attributes = Array.from(node.attributes);

            // 指令進行編譯
            if (hasDirective(attributes, "v-bind")) {
              const attrVal = getDirectiveValue(node, attributes, "v-bind");
              const exp = getDirectiveParams(attributes, "v-bind");
              // const 
              node.setAttribute(exp, this.$data[attrVal])
              this._binding[attrVal].push(new watcher({
                vm: this, 
                el: node,
                exp,
                attr: attrVal
              }))
            }
            if (hasDirective(attributes, "v-on")) {
              const eventName = getDirectiveParams(attributes, "v-on");
              node.addEventListener(eventName, (e) => {
                this.$methods[getDirectiveValue(node, attributes, "v-on")].call(this)
              })
            }
            if (node.hasAttribute("v-model") && node.tagName === "INPUT" || node.tagName === "TEXTAREA") {
              let attrVal = node.getAttribute("v-model");
              this._binding[attrVal].push(new Watcher({
                  vm: this,
                  el: node,
                  attr: attrVal,
                  name: "v-model"
                }))
              node.addEventListener("input", e=> {
                this.$data[attrVal] = node.value;
              })
              node.value = this.$data[attrVal]
            }

            // 遞歸接著處理
            if (node.hasChildNodes()) {
              this._compile(node)
            }
          }

          // 文本節點
          if (node.nodeType === 3) {
            let text = node.textContent;

            let keyArr = [];
            // 獲取{{變量}}，用正則去匹配；watcher去觀察{{變量}}(包裹元素)，
            let newText = text.replace(/{{(w+)}}/g, (match, p0)=> {
              keyArr = [...keyArr, p0];
              // 替換屬性為真正的屬性值
              return this.$data[p0]
            })
            node.textContent = newText;

            // 把整個文本節點進行監控{{v1}}-----{{v2}}；添加到訂閱到數組里等待通知
            keyArr.forEach(key => {
              // !this._binding[key] && (this._binding[key] = [])
              this._binding[key].push(new Watcher({
                vm: this,
                el: node,
                attr: text
              }))
            })
          }
        })
      }

觀察者實例

class Watcher {
      constructor({
        vm,
        name,
        el,
        exp,
        attr,
      }) {
        this.vm = vm;
        this.el = el;
        this.name = name;
        this.exp = exp;
        this.attr = attr;
      }
      // 更新text,或更新屬性
      update() {
        // 改變節點的屬性
        if (this.el.nodeType === 1) {
          // this.el.value = this.vm.$data[this.exp]
          if (this.name === "v-model") {
            console.log("value", this.el)
            this.el.value = this.vm.$data[this.attr]
          }
          this.el[this.attr] = this.vm.$data[this.exp]
        }
        // 文本節點
        else {
          let text = this.attr;
          // 獲取{{變量}}，用正則去匹配；watcher去觀察{{變量}}(包裹元素)，
          let newText = text.replace(/{{(w+)}}/g, (match, p0)=> {
            // 替換屬性為真正的屬性值
            return this.vm.$data[p0]
          })
          this.el.textContent = newText;
        }
      }
    }

整體代碼

  
  
  
  
  


  

    
    
{{title}}
    
{{text}}
    
    增加
    減少
    
    
我點的時候就會變化{{number}}---{{number}}