2. 程式人生 > >vue.js響應式原理解析與實現—實現v-model與{{}}指令

vue.js響應式原理解析與實現—實現v-model與{{}}指令

阿新 • • 發佈：2018-11-12
只需要 spl foreach 形式 pen for 元素節點 目標 @param

離線瀏覽器軟件 服務器遠程連接

1、可多站同時下載、多站同時扒

2、可單頁扒

3、可自定義， 重寫JS\圖片\CSS路徑

4、執行全站下載後，會下載到本程序根目錄下的html文件夾下。

5、全站替換，根據關鍵詞替換。N個（多個）關鍵詞替換。
6、多線程下載
7、自動補齊404不存在的鏈接頁面（下載大站的時候需要）
8、插入自定義的JS（全站插入）
9、整站下載
10、單頁下載

此程序可以做到:

1，快速多線程下載整站，無論任何後綴（動態或者靜態）。

2，全站無錯下載，包含CSS\JS\圖片等等。

上次我們已經分析了vue.js是通過Object.defineProperty以及發布訂閱模式來進行數據劫持和監聽,並且實現了一個簡單的demo。今天，我們就基於上一節的代碼，來實現一個MVVM類，將其與html結合在一起，並且實現v-model以及{{}}語法。

tips:本節新增代碼（去除註釋）在一百行左右。使用的Observer和Watcher都是延用上一節的代碼，沒有修改。

接下來，讓我們一步步來，實現一個MVVM類。

構造函數

首先，一個MVVM的構造函數如下(和vue.js的構造函數一樣)：

class MVVM {
  constructor({ data, el }) {
    this.data = data;
    this.el = el;
    this.init();
    this.initDom();
  }
}

　　

和vue.js一樣，有它的data屬性以及el元素。

初始化操作

vue.js可以通過this.xxx的方法來直接訪問this.data.xxx的屬性，這一點是怎麽做到的呢？其實答案很簡單，它是通過Object.defineProperty來做手腳，當你訪問this.xxx的時候，它返回的其實是this.data.xxx。當你修改this.xxx值的時候，其實修改的是this.data.xxx的值。具體可以看如下代碼：

class MVVM {
  constructor({ data, el }) {
    this.data = data;
    this.el = el;
    this.init();
    this.initDom();
  }
  // 初始化
  init() {
    // 對this.data進行數據劫持
    new Observer(this.data);
    // 傳入的el可以是selector,也可以是元素，因此我們要在這裏做一層處理，保證this.$el的值是一個元素節點
    this.$el = this.isElementNode(this.el) ? this.el : document.querySelector(this.el);
    // 將this.data的屬性都綁定到this上，這樣用戶就可以直接通過this.xxx來訪問this.data.xxx的值
    for (let key in this.data) {
      this.defineReactive(key);
    }
  }

  defineReactive(key) {
    Object.defineProperty(this, key, {
      get() {
        return this.data[key];
      },
      set(newVal) {
        this.data[key] = newVal;
      } //前端全棧學習交流圈：866109386
    })//面向1-3年前端開發人員
  }//幫助突破技術瓶頸，提升思維能力。
  // 是否是屬性節點
  isElementNode(node) {
    return node.nodeType === 1;
  }
}

　　

在完成初始化操作後，我們需要對this.$el的節點進行編譯。目前我們要實現的語法有v-model和{{}}語法,v-model這個屬性只可能會出現在元素節點的attributes裏，而{{}}語法則是出現在文本節點裏。

fragment

在對節點進行編譯之前，我們先考慮一個現實問題：如果我們在編譯過程中直接操作DOM節點的話，每一次修改DOM都會導致DOM的回流或重繪，而這一部分性能損耗是很沒有必要的。因此，我們可以利用fragment,將節點轉化為fragment,然後在fragment裏編譯完成後，再將其放回到頁面上。

class MVVM {
  constructor({ data, el }) {
    this.data = data;
    this.el = el;//前端全棧交流學習圈：866109386
    this.init();//針對1-3年前端開發人員
    this.initDom();//幫助突破技術瓶頸，提升思維能力。
  }

  initDom() {
    const fragment = this.node2Fragment();
    this.compile(fragment);
    // 將fragment返回到頁面中
    document.body.appendChild(fragment);
  }
  // 將節點轉為fragment,通過fragment來操作DOM，可以獲得更高的效率
  // 因為如果直接操作DOM節點的話，每次修改DOM都會導致DOM的回流或重繪，而將其放在fragment裏，修改fragment不會導致DOM回流和重繪
  // 當在fragment一次性修改完後，在直接放回到DOM節點中
  node2Fragment() {
    const fragment = document.createDocumentFragment();
    let firstChild;
    while(firstChild = this.$el.firstChild) {
      fragment.appendChild(firstChild);
    }
    return fragment;
  }
}

　　

實現v-model

在將node節點轉為fragment後，我們來對其中的v-model語法進行編譯。

由於v-model語句只可能會出現在元素節點的attributes裏，因此，我們先判斷該節點是否為元素節點，若為元素節點，則判斷其是否是directive(目前只有v-model)，若都滿足的話，則調用CompileUtils.compileModelAttr來編譯該節點。

編譯含有v-model的節點主要有兩步：

  1. 為元素節點註冊input事件，在input事件觸發的時候，更新vm(this.data)上對應的屬性值。
  2. 對v-model依賴的屬性註冊一個Watcher函數，當依賴的屬性發生變化，則更新元素節點的value。
class MVVM {
  constructor({ data, el }) {
    this.data = data;
    this.el = el;
    this.init();
    this.initDom();
  }

  initDom() {
    const fragment = this.node2Fragment();
    this.compile(fragment);
    // 將fragment返回到頁面中
    document.body.appendChild(fragment);
  }

  compile(node) {
    if (this.isElementNode(node)) {
      // 若是元素節點，則遍歷它的屬性，編譯其中的指令
      const attrs = node.attributes;
      Array.prototype.forEach.call(attrs, (attr) => {
        if (this.isDirective(attr)) {
          CompileUtils.compileModelAttr(this.data, node, attr)
        }
      })
    }
    // 若節點有子節點的話，則對子節點進行編譯
    if (node.childNodes && node.childNodes.length > 0) {
      Array.prototype.forEach.call(node.childNodes, (child) => {
        this.compile(child);
      })
    }
  }
  // 是否是屬性節點
  isElementNode(node) {
    return node.nodeType === 1;
  }
  // 檢測屬性是否是指令(vue的指令是v-開頭)
  isDirective(attr) {
    return attr.nodeName.indexOf(‘v-‘) >= 0;
  }
}

const CompileUtils = {
  // 編譯v-model屬性,為元素節點註冊input事件，在input事件觸發的時候，更新vm對應的值。
  // 同時也註冊一個Watcher函數，當所依賴的值發生變化的時候，更新節點的值
  compileModelAttr(vm, node, attr) {
    const { value: keys, nodeName } = attr;
    node.value = this.getModelValue(vm, keys);
    // 將v-model屬性值從元素節點上去掉
    node.removeAttribute(nodeName);
    node.addEventListener(‘input‘, (e) => {
      this.setModelValue(vm, keys, e.target.value);
    });

    new Watcher(vm, keys, (oldVal, newVal) => {
      node.value = newVal;
    });
  },
  /* 解析keys，比如，用戶可以傳入
  *  <input v-model="obj.name" />
  *  這個時候，我們在取值的時候，需要將"obj.name"解析為data[obj][name]的形式來獲取目標值
  */
  parse(vm, keys) {
    keys = keys.split(‘.‘);
    let value = vm;
    keys.forEach(_key => {
      value = value[_key];
    });
    return value;
  },
  // 根據vm和keys，返回v-model對應屬性的值
  getModelValue(vm, keys) {
    return this.parse(vm, keys);
  },
  // 修改v-model對應屬性的值
  setModelValue(vm, keys, val) {
    keys = keys.split(‘.‘);
    let value = vm;
    for(let i = 0; i < keys.length - 1; i++) {
      value = value[keys[i]];
    }
    value[keys[keys.length - 1]] = val;
  },
}

　　

實現{{}}語法

{{}}語法只可能會出現在文本節點中，因此，我們只需要對文本節點做處理。如果文本節點中出現{{key}}這種語句的話，我們則對該節點進行編譯。在這裏，我們可以通過下面這個正則表達式來對文本節點進行處理，判斷其是否含有{{}}語法。

const textReg = /\{\{\s*\w+\s*\}\}/gi; // 檢測{{name}}語法
console.log(textReg.test(‘sss‘));
console.log(textReg.test(‘aaa{{  name  }}‘));
console.log(textReg.test(‘aaa{{  name  }} {{ text }}‘));

　　

若含有{{}}語法，我們則可以對其處理，由於一個文本節點可能出現多個{{}}語法，因此編譯含有{{}}語法的文本節點主要有以下兩步：

  1. 找出該文本節點中所有依賴的屬性，並且保留原始文本信息，根據原始文本信息還有屬性值，生成最終的文本信息。比如說，原始文本信息是"test {{test}} {{name}}",那麽該文本信息依賴的屬性有this.data.test和this.data.name,那麽我們可以根據原本信息和屬性值，生成最終的文本。
  2. 為該文本節點所有依賴的屬性註冊Watcher函數，當依賴的屬性發生變化的時候，則更新文本節點的內容。
class MVVM {
  constructor({ data, el }) {
    this.data = data;
    this.el = el;
    this.init();
    this.initDom();
  }

  initDom() {
    const fragment = this.node2Fragment();
    this.compile(fragment);
    // 將fragment返回到頁面中
    document.body.appendChild(fragment);
  }

  compile(node) {
    const textReg = /\{\{\s*\w+\s*\}\}/gi; // 檢測{{name}}語法
    if (this.isTextNode(node)) {
      // 若是文本節點，則判斷是否有{{}}語法，如果有的話，則編譯{{}}語法
      let textContent = node.textContent;
      if (textReg.test(textContent)) {
        // 對於 "test{{test}} {{name}}"這種文本，可能在一個文本節點會出現多個匹配符，因此得對他們統一進行處理
        // 使用 textReg來對文本節點進行匹配，可以得到["{{test}}", "{{name}}"]兩個匹配值
        const matchs = textContent.match(textReg);
        CompileUtils.compileTextNode(this.data, node, matchs);
      }
    }
    // 若節點有子節點的話，則對子節點進行編譯
    if (node.childNodes && node.childNodes.length > 0) {
      Array.prototype.forEach.call(node.childNodes, (child) => {
        this.compile(child);
      })
    }
  }
  // 是否是文本節點
  isTextNode(node) {
    return node.nodeType === 3;
  }
}

const CompileUtils = {
  reg: /\{\{\s*(\w+)\s*\}\}/, // 匹配 {{ key }}中的key
  // 編譯文本節點，並註冊Watcher函數，當文本節點依賴的屬性發生變化的時候，更新文本節點
  compileTextNode(vm, node, matchs) {
    // 原始文本信息
    const rawTextContent = node.textContent;
    matchs.forEach((match) => {
      const keys = match.match(this.reg)[1];
      console.log(rawTextContent);
      new Watcher(vm, keys, () => this.updateTextNode(vm, node, matchs, rawTextContent));
    });
    this.updateTextNode(vm, node, matchs, rawTextContent);
  },
  // 更新文本節點信息
  updateTextNode(vm, node, matchs, rawTextContent) {
    let newTextContent = rawTextContent;
    matchs.forEach((match) => {
      const keys = match.match(this.reg)[1];
      const val = this.getModelValue(vm, keys);
      newTextContent = newTextContent.replace(match, val);
    })
    node.textContent = newTextContent;
  }
}

　　

結語

這樣，一個具有v-model和{{}}功能的MVVM類就已經完成了

這裏也有一個簡單的樣例(忽略樣式)。

接下來的話，可能會繼續實現computed屬性,v-bind方法，以及支持在{{}}裏面放表達式。如果覺得這個文章對你有幫助的話，麻煩點個贊，嘻嘻。

最後，貼上所有的代碼:

class Observer {
  constructor(data) {
    // 如果不是對象，則返回
    if (!data || typeof data !== ‘object‘) {
      return;
    }
    this.data = data;
    this.walk();
  }

  // 對傳入的數據進行數據劫持
  walk() {
    for (let key in this.data) {
      this.defineReactive(this.data, key, this.data[key]);
    }
  }
  // 創建當前屬性的一個發布實例，使用Object.defineProperty來對當前屬性進行數據劫持。
  defineReactive(obj, key, val) {
    // 創建當前屬性的發布者
    const dep = new Dep();
    /*
    * 遞歸對子屬性的值進行數據劫持，比如說對以下數據
    * let data = {
    *   name: ‘cjg‘,
    *   obj: {
    *     name: ‘zht‘,
    *     age: 22,
    *     obj: {
    *       name: ‘cjg‘,
    *       age: 22,
    *     }
    *   },
    * };
    * 我們先對data最外層的name和obj進行數據劫持，之後再對obj對象的子屬性obj.name,obj.age, obj.obj進行數據劫持，層層遞歸下去，直到所有的數據都完成了數據劫持工作。
    */
    new Observer(val);
    Object.defineProperty(obj, key, {
      get() {
        // 若當前有對該屬性的依賴項，則將其加入到發布者的訂閱者隊列裏
        if (Dep.target) {
          dep.addSub(Dep.target);
        }
        return val;
      },
      set(newVal) {
        if (val === newVal) {
          return;
        }
        val = newVal;
        new Observer(newVal);
        dep.notify();
      }
    })
  }
}

// 發布者,將依賴該屬性的watcher都加入subs數組，當該屬性改變的時候，則調用所有依賴該屬性的watcher的更新函數，觸發更新。
class Dep {
  constructor() {
    this.subs = [];
  }

  addSub(sub) {
    if (this.subs.indexOf(sub) < 0) {
      this.subs.push(sub);
    }
  }

  notify() {
    this.subs.forEach((sub) => {
      sub.update();
    })
  }
}

Dep.target = null;

// 觀察者
class Watcher {
  /**
   *Creates an instance of Watcher.
   * @param {*} vm
   * @param {*} keys
   * @param {*} updateCb
   * @memberof Watcher
   */
  constructor(vm, keys, updateCb) {
    this.vm = vm;
    this.keys = keys;
    this.updateCb = updateCb;
    this.value = null;
    this.get();
  }

  // 根據vm和keys獲取到最新的觀察值
  get() {
    // 將Dep的依賴項設置為當前的watcher,並且根據傳入的keys遍歷獲取到最新值。
    // 在這個過程中，由於會調用observer對象屬性的getter方法，因此在遍歷過程中這些對象屬性的發布者就將watcher添加到訂閱者隊列裏。
    // 因此，當這一過程中的某一對象屬性發生變化的時候，則會觸發watcher的update方法
    Dep.target = this;
    this.value = CompileUtils.parse(this.vm, this.keys);
    Dep.target = null;
    return this.value;
  }

  update() {
    const oldValue = this.value;
    const newValue = this.get();
    if (oldValue !== newValue) {
      this.updateCb(oldValue, newValue);
    }
  }
}

class MVVM {
  constructor({ data, el }) {
    this.data = data;
    this.el = el;
    this.init();
    this.initDom();
  }

  // 初始化
  init() {
    // 對this.data進行數據劫持
    new Observer(this.data);
    // 傳入的el可以是selector,也可以是元素，因此我們要在這裏做一層處理，保證this.$el的值是一個元素節點
    this.$el = this.isElementNode(this.el) ? this.el : document.querySelector(this.el);
    // 將this.data的屬性都綁定到this上，這樣用戶就可以直接通過this.xxx來訪問this.data.xxx的值
    for (let key in this.data) {
      this.defineReactive(key);
    }
  }

  initDom() {
    const fragment = this.node2Fragment();
    this.compile(fragment);
    document.body.appendChild(fragment);
  }
  // 將節點轉為fragment,通過fragment來操作DOM，可以獲得更高的效率
  // 因為如果直接操作DOM節點的話，每次修改DOM都會導致DOM的回流或重繪，而將其放在fragment裏，修改fragment不會導致DOM回流和重繪
  // 當在fragment一次性修改完後，在直接放回到DOM節點中
  node2Fragment() {
    const fragment = document.createDocumentFragment();
    let firstChild;
    while(firstChild = this.$el.firstChild) {
      fragment.appendChild(firstChild);
    }
    return fragment;
  }

  defineReactive(key) {
    Object.defineProperty(this, key, {
      get() {
        return this.data[key];
      },
      set(newVal) {
        this.data[key] = newVal;
      }
    })
  }

  compile(node) {
    const textReg = /\{\{\s*\w+\s*\}\}/gi; // 檢測{{name}}語法
    if (this.isElementNode(node)) {
      // 若是元素節點，則遍歷它的屬性，編譯其中的指令
      const attrs = node.attributes;
      Array.prototype.forEach.call(attrs, (attr) => {
        if (this.isDirective(attr)) {
          CompileUtils.compileModelAttr(this.data, node, attr)
        }
      })
    } else if (this.isTextNode(node)) {
      // 若是文本節點，則判斷是否有{{}}語法，如果有的話，則編譯{{}}語法
      let textContent = node.textContent;
      if (textReg.test(textContent)) {
        // 對於 "test{{test}} {{name}}"這種文本，可能在一個文本節點會出現多個匹配符，因此得對他們統一進行處理
        // 使用 textReg來對文本節點進行匹配，可以得到["{{test}}", "{{name}}"]兩個匹配值
        const matchs = textContent.match(textReg);
        CompileUtils.compileTextNode(this.data, node, matchs);
      }
    }
    // 若節點有子節點的話，則對子節點進行編譯。
    if (node.childNodes && node.childNodes.length > 0) {
      Array.prototype.forEach.call(node.childNodes, (child) => {
        this.compile(child);
      })
    }
  }

  // 是否是屬性節點
  isElementNode(node) {
    return node.nodeType === 1;
  }
  // 是否是文本節點
  isTextNode(node) {
    return node.nodeType === 3;
  }

  isAttrs(node) {
    return node.nodeType === 2;
  }
  // 檢測屬性是否是指令(vue的指令是v-開頭)
  isDirective(attr) {
    return attr.nodeName.indexOf(‘v-‘) >= 0;
  }

}

const CompileUtils = {
  reg: /\{\{\s*(\w+)\s*\}\}/, // 匹配 {{ key }}中的key
  // 編譯文本節點，並註冊Watcher函數，當文本節點依賴的屬性發生變化的時候，更新文本節點
  compileTextNode(vm, node, matchs) {
    // 原始文本信息
    const rawTextContent = node.textContent;
    matchs.forEach((match) => {
      const keys = match.match(this.reg)[1];
      console.log(rawTextContent);
      new Watcher(vm, keys, () => this.updateTextNode(vm, node, matchs, rawTextContent));
    });
    this.updateTextNode(vm, node, matchs, rawTextContent);
  },
  // 更新文本節點信息
  updateTextNode(vm, node, matchs, rawTextContent) {
    let newTextContent = rawTextContent;
    matchs.forEach((match) => {
      const keys = match.match(this.reg)[1];
      const val = this.getModelValue(vm, keys);
      newTextContent = newTextContent.replace(match, val);
    })
    node.textContent = newTextContent;
  },
  // 編譯v-model屬性,為元素節點註冊input事件，在input事件觸發的時候，更新vm對應的值。
  // 同時也註冊一個Watcher函數，當所依賴的值發生變化的時候，更新節點的值
  compileModelAttr(vm, node, attr) {
    const { value: keys, nodeName } = attr;
    node.value = this.getModelValue(vm, keys);
    // 將v-model屬性值從元素節點上去掉
    node.removeAttribute(nodeName);
    new Watcher(vm, keys, (oldVal, newVal) => {
      node.value = newVal;
    });
    node.addEventListener(‘input‘, (e) => {
      this.setModelValue(vm, keys, e.target.value);
    });
  },
  /* 解析keys，比如，用戶可以傳入
  *  let data = {
  *    name: ‘cjg‘,
  *    obj: {
  *      name: ‘zht‘,
  *    },
  *  };
  *  new Watcher(data, ‘obj.name‘, (oldValue, newValue) => {
  *    console.log(oldValue, newValue);
  *  })
  *  這個時候，我們需要將keys解析為data[obj][name]的形式來獲取目標值
  */
  parse(vm, keys) {
    keys = keys.split(‘.‘);
    let value = vm;
    keys.forEach(_key => {
      value = value[_key];
    });
    return value;
  },
  // 根據vm和keys，返回v-model對應屬性的值
  getModelValue(vm, keys) {
    return this.parse(vm, keys);
  },
  // 修改v-model對應屬性的值
  setModelValue(vm, keys, val) {
    keys = keys.split(‘.‘);
    let value = vm;
    for(let i = 0; i < keys.length - 1; i++) {
      value = value[keys[i]];
    }
    value[keys[keys.length - 1]] = val;
  },
}

　　

vue.js響應式原理解析與實現—實現v-model與{{}}指令

相關推薦

vue.js響應式原理解析與實現

github 遞歸 val 實現 mode 最新 中比 ava 新頁面 從很久之前就已經接觸過了angularjs了，當時就已經了解到，angularjs是通過臟檢查來實現數據監測以及頁面更新渲染。之後，再接觸了vue.js，當時也一度很好奇vue.js是如何監測數據更新並

vue.js響應式原理解析與實現—實現v-model與{{}}指令

只需要 spl foreach 形式 pen for 元素節點 目標 @param 離線瀏覽器軟件 服務器遠程連接 1、可多站同時下載、多站同時扒 2、可單頁扒 3、可自定義， 重寫JS\圖片\CSS路徑 4、執行全站下載後，會下載到本程序根目錄下的html文件夾下。

深入解析vue.js響應式原理與實現

vue.js響應式原理解析與實現。angularjs是通過髒檢查來實現資料監測以及頁面更新渲染。之後，再接觸了vue.js，當時也一度很好奇vue.js是如何監測資料更新並且重新渲染頁面。vue.js響應式原理解析與實現 Object.defineProperty es5新增了

vue系列---響應式原理實現及Observer原始碼解析(一)

閱讀目錄 一. 什麼是響應式？ 二：如何偵測資料的變化？ 2.1 Object.defineProperty() 偵測物件屬性值變化 2.2 如何偵測陣列的索引值的變化 2.3 如何監聽陣列內容的增加或減少？ 2.4 使用Proxy來實現資料監聽 三. Observer原始碼解析

Vue的響應式原理（MVVM）深入解析

1. 如何實現一個響應式物件 最近在看 Vue 的原始碼，其中最核心基礎的一塊就是 Observer/Watcher/Dep, 簡而言之就是，Vue 是如何攔截資料的讀寫， 如果實現對應的監聽，並且特定的監聽執行特定的回撥或者渲染邏輯的。總的可以拆成三大塊來說

關於vue的響應式原理

define fin data vue 轉化 數據 收集 get() 不支持 Vue 是基於Object.defineProperty()來實現數據響應的，而Object.defineProperty()是ES5無法 shim（修復） 的特性 這也就是Vue不支持 IE8以

Vue 資料響應式原理

Vue 資料響應式原理 Vue.js 的核心包括一套“響應式系統”。“響應式”，是指當資料改變後，Vue 會通知到使用該資料的程式碼。例如，檢視渲染中使用了資料，資料改變後，檢視也會自動更新。 舉個簡單的例子，對於模板： {{ name }} 建立一個 Vue 元件： var vm = new

vue的響應式原理

es5 start 被調用 too 調用 value prop 內部 一個 　　Vue 最獨特的特性之一，是其非侵入性的響應式系統。數據模型僅僅是普通的 JavaScript 對象。而當修改它們時，視圖會進行更新。 　　 　　當我們把一個普通的 JavaScript 對象傳

Vue深入響應式原理（雙向繫結原理）

    Vue用了快一年了，一直沒有花時間去了解過它的原理，對於雙向繫結這塊，也只知道在專案中怎麼使用。在網上百度了一波後，發現我有知識都沒接觸過，今天就來好好整理一下。   我理解的Vue雙向繫結的大致思路如下： （1）Vue會使用documentfragment劫持根

Vue.js 深入響應式原理

深入響應式原理 現在是時候深入一下了！Vue 最獨特的特性之一，是其非侵入性的響應式系統。資料模型僅僅是普通的 JavaScript 物件。而當你修改它們時，檢視會進行更新。這使得狀態管理非常簡單直接，不過理解其工作原理同樣重要，這樣你可以迴避一些常見的問題。在這個章節，我們將進入一些 Vue

Vue 進階系列之響應式原理及實現

什麼是響應式Reactivity Reactivity表示一個狀態改變之後，如何動態改變整個系統，在實際專案應用場景中即資料如何動態改變Dom。 需求 現在有一個需求，有a和b兩個變數，要求b一直是a的10倍，怎麼做？ 簡單嘗試1： let a = 3; let b

vue響應式原理學習（三）— Watcher的實現

普及知識點 為什麼我們改變了資料，Vue能夠自動幫我們重新整理DOM。就是因為有 Watcher。當然，Watcher 只是派發資料更新，真正的修改DOM，還需要借用VNode，我們這裡先不討論VNode。 computed 計算屬性，內部實現也是基於 Watcher watc

Vue.js 原始碼全方位深入解析 學精學透 Vue 原理實現

第1章 準備工作介紹了 Flow、Vue.js 的原始碼目錄設計、Vue.js 的原始碼構建方式，以及從入口開始分析了 Vue.js 的初始化過程。1-1 課程簡介1-2 準備工作1-3 認識 Flow-文件1-4 認識 Flow1-5 Vue.js 原始碼目錄設計-文件1-

vue2.x響應式原理，vue與react響應式簡單對比

配合ppt食用更佳ppt 實現的最終目標 const demo = new Vue({ data: { text: "before", }, // 對應的template 為 <div><span>{{text

手寫實現vue的MVVM響應式原理

　　MVVM響應式實現原理： 　　1.模板編譯 　　2.資料劫持 　　3.watcher 　　MVVM------------------檢視-----模型----檢視模型 　　三者與Vue的對應：view對應template，vm對應newVue({…})，model對應data 　　文中應用到的資料名詞：

深入解析vue響應式原理

摘要：本文主要通過結合vue官方文件及原始碼，對vue響應式原理進行深入分析。 1.定義 作為vue最獨特的特性，響應式可以說是vue的靈魂了，表面上看就是資料發生變化後，對應的介面會重新渲染，那麼響應式系統的底層細節到底是怎麼一回事呢？ Tips:vue的響應式系統在vue2.0和vue3.0版本中的底層實

Vue響應式原理

允許 clas 沒有 改變 $set 開發 轉化 閱讀 提前 前面的話 　　Vue最顯著的特性之一便是不太引人註意的響應式系統(reactivity system)。模型層(model)只是普通JS對象，修改它則更新視圖(view)。這會讓狀態管理變得非常簡單且直觀，不過

深入響應式原理--Vue

執行 ide 格式 dev fun 添加屬性 類型 即使 develop Vue 最顯著的特性之一便是不太引人註意的響應式系統(reactivity system)。模型層(model)只是普通 JavaScript 對象，修改它則更新視圖(view)。這會讓狀態管理變

vue 響應式原理

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Document</tit

深入淺出Vue基於“依賴收集”的響應式原理

原文地址： https://zhuanlan.zhihu.com/p/29318017 每當問到VueJS響應式原理，大家可能都會脫口而出“Vue通過Object.defineProperty方法把data物件的全部屬性轉化成getter/setter，當屬性被訪問或修改時