配合ppt食用更佳ppt

實現的最終目標

const demo = new Vue({
  data: {
    text: "before",
  },
  // 對應的template 為 <div><span>{{text}}</span></div>
  render(h){
    return h('div', {}, [
      h('span', {}, [this.__toString__(this.text)])
    ])
  }
})
setTimeout(function(){
  demo.text = "after"
 

}, 3000)

對應的虛擬DOM會從

<div><span>before</span></div> 

變成

 <div><span>after</span></div>

第一步,監聽data下邊的所有屬性，轉換為響應式

思路

• 當data下的某個屬性變化時，如何觸發相應的函式？

方案：ES5中新添加了一個方法:Object.defineProperty，通過這個方法，可以自定義getter和setter函式，那麼在獲取物件屬性或者設定物件屬性時就能夠執行相應的回撥函式

程式碼如下：

class Vue {
  constructor(options) {
    this.$options = options
    this._data = options.data
    observer(options.data, this._update.bind(this))
    this._update()
  }
  _update(){
    this.$options.render()
  }
}

function observer(obj, cb) {
  Object.keys(obj).forEach((key) => {
    defineReactive(obj, key, obj[key], cb)
  })
}

function
 
 defineReactive(obj, key, val, cb) {
  Object.defineProperty(obj, key, {
    enumerable: true,
    configurable: true,
    get: () => {
      console.log('你訪問了' + key)
      return val
    },
    set: newVal => {
      if (newVal === val)
        return
      console.log('你設定了' + key)
      console.log('新的' + key + ' = ' + newVal)
      val = newVal
      cb()
    }
  })
}

var demo1 = new Vue({
  el: '#demo',
  data: {
    text: "before"
  },
  render(){
    console.log("我要render了")
  }
})

• 引發了第二個問題，如果data中的屬性是一個物件還能觸發我們的回掉函式麼？比如說下邊的demo

var demo2 = new Vue({
  el: '#demo',
  data: {
    text: "before",
    o: {
      text: "o-before"
    }
  },
  render(){
    console.log("我要render了")
  }
})

方案：用遞迴完善上邊的響應式，需要在它開始對屬性進行響應式轉換的時候，前邊加個判斷，即如下

function observer(obj) {
  Object.keys(obj).forEach((key) => {
    if (typeof obj[key] === 'object') {
      new observer(obj[key], cb)
    }
    defineReactive(obj, key, obj[key])
  })
}

• 實際寫的過程中發現呼叫data的屬性時需要這樣寫demo._data.text，肯定是沒有demo.text這樣寫來的方便，所以就需要加一層代理進行轉換

程式碼如下：

  _proxy(key) {
    const self = this
    Object.defineProperty(self, key, {
      configurable: true,
      enumerable: true,
      get: function proxyGetter() {
        return self._data[key]
      },
      set: function proxySetter(val) {
        self._data[key] = val
      }
    })
  }

然後在建構函式中加上這麼一句話

Object.keys(options.data).forEach(key => this._proxy(key))

到此，我們的data屬性已經變為響應式的了，只要data的屬性發生變化，那麼就會觸發render函式。這也是為什麼只有vue元件中的data屬性才是響應式的，其他地方宣告的值均不是響應式的原因。但是這裡有個問題，即觸發render函式的準確度問題！

第二步，解決準確度問題，引出虛擬dom

比如下邊的demo

new Vue({
  template: `
    <div>
      <span>name:</span> {{name}}
    <div>`,
  data: {
    name: 'js',
    age: 24
  }
})

setTimeout(function(){
  demo.age = 25
}, 3000)

template中只用到了data中的name屬性，但是當修改age屬性的時候，會不會觸發渲染呢？答案是：會。但實際是不需要觸發渲染機制的

解決這個問題，先要簡單說下虛擬dom。vue有兩種寫法：

// template模板寫法（最常用的）
new Vue({
  data: {
    text: "before",
  },
  template: `
    <div>
      <span>text:</span> {{text}}
    </div>`
})

// render函式寫法，類似react的jsx寫法
new Vue({
  data: {
    text: "before",
  },
  render (h) {
    return (
      <div>
        <span>text:</span> {{text}}
      </div>
    )
  }
})

由於vue2.x引入了虛擬dom的原因，這兩種寫法最終都會被解析成虛擬dom，但在這之前，他們會先被解析函式轉換成同一種表達方式，即如下：

new Vue({
  data: {
    text: "before",
  },
  render(){
    return this.__h__('div', {}, [
      this.__h__('span', {}, [this.__toString__(this.text)])
    ])
  }
})

透過上邊的render函式中的this.__h__方法，可以簡單瞭解下虛擬dom

function VNode(tag, data, children, text) {
  return {
    tag: tag, // html標籤名
    data: data, // 包含諸如 class 和 style 這些標籤上的屬性
    children: children, // 子節點
    text: text // 文字節點
  }
}

寫一個簡單的虛擬dom：

function VNode(tag, data, children, text) {
  return {
    tag: tag,
    data: data,
    children: children,
    text: text
  }
}

class Vue {
  constructor(options) {
    this.$options = options
    const vdom = this._update()
    console.log(vdom)
  }
  _update() {
    return this._render.call(this)
  }
  _render() {
    const vnode = this.$options.render.call(this)
    return vnode
  }
  __h__(tag, attr, children) {
    return VNode(tag, attr, children.map((child)=>{
      if(typeof child === 'string'){
        return VNode(undefined, undefined, undefined, child)
      }else{
        return child
      }
    }))
  }
  __toString__(val) {
    return val == null ? '' : typeof val === 'object' ? JSON.stringify(val, null, 2) : String(val);
  }
}

var demo = new Vue({
  el: '#demo',
  data: {
    text: "before",
  },
  render(){
    return this.__h__('div', {}, [
      this.__h__('span', {}, [this.__toString__(this.text)])
    ])
  }
})

回頭看問題，也就是說，我需要知道render函式中依賴了data中的哪些屬性，只有這些屬性變化，才需要去觸發render函式

第三步，依賴收集，準確渲染

思路：在這之前，我們已經把data中的屬性改成響應式了，當去獲取或者修改這些變數時便能夠觸發相應函式。那這裡就可以利用這個相應的函式做些手腳了。當宣告一個vue物件時，在執行render函式獲取虛擬dom的這個過程中，已經對render中依賴的data屬性進行了一次獲取操作，這次獲取操作便可以拿到所有依賴。

其實不僅是render，任何一個變數的改別，是因為別的變數改變引起，都可以用上述方法，也就是computed和watch的原理

首先需要寫一個依賴收集的類，每一個data中的屬性都有可能被依賴，因此每個屬性在響應式轉化（defineReactive）的時候，就初始化它。程式碼如下：

class Dep {
  constructor() {
    this.subs = []
  }
  add(cb) {
    this.subs.push(cb)
  }
  notify() {
    console.log(this.subs)
    this.subs.forEach((cb) => cb())
  }
}

function defineReactive(obj, key, val, cb) {
  const dep = new Dep()
  Object.defineProperty(obj, key, {
    // 省略
  })
}

那麼執行過程就是:
- 當執行render函式的時候，依賴到的變數的get就會被執行，然後就把這個 render函式加到subs裡面去。
- 當set的時候,就執行notify，將所有的subs數組裡的函式執行，其中就包含render的執行。

注：程式碼中有一個Dep.target值，這個值時用來區分是普通的get還是收集依賴時的get

最後完整程式碼如下：

function VNode(tag, data, children, text) {
  return {
    tag: tag,
    data: data,
    children: children,
    text: text
  }
}

class Vue {
  constructor(options) {
    this.$options = options
    this._data = options.data
    Object.keys(options.data).forEach(key => this._proxy(key))
    observer(options.data)
    const vdom = watch(this, this._render.bind(this), this._update.bind(this))
    console.log(vdom)
  }
  _proxy(key) {
    const self = this
    Object.defineProperty(self, key, {
      configurable: true,
      enumerable: true,
      get: function proxyGetter() {
        return self._data[key]
      },
      set: function proxySetter(val) {
        self._data[key] = val
      }
    })
  }
  _update() {
    console.log("我需要更新");
    const vdom = this._render.call(this)
    console.log(vdom);
  }
  _render() {
    return this.$options.render.call(this)
  }
  __h__(tag, attr, children) {
    return VNode(tag, attr, children.map((child) => {
      if (typeof child === 'string') {
        return VNode(undefined, undefined, undefined, child)
      } else {
        return child
      }
    }))
  }
  __toString__(val) {
    return val == null ? '' : typeof val === 'object' ? JSON.stringify(val, null, 2) : String(val);
  }
}

function observer(obj) {
  Object.keys(obj).forEach((key) => {
    if (typeof obj[key] === 'object') {
      new observer(obj[key])
    }
    defineReactive(obj, key, obj[key])
  })
}

function defineReactive(obj, key, val) {
  const dep = new Dep()
  Object.defineProperty(obj, key, {
    enumerable: true,
    configurable: true,
    get: () => {
      if (Dep.target) {
        dep.add(Dep.target)
        Dep.target = null
      }
      console.log('你訪問了' + key)
      return val
    },
    set: newVal => {
      if (newVal === val)
        return
      console.log('你設定了' + key)
      console.log('新的' + key + ' = ' + newVal)
      val = newVal
      dep.notify()
    }
  })
}

function watch(vm, exp, cb) {
  Dep.target = cb
  return exp()
}

class Dep {
  constructor() {
    this.subs = []
  }
  add(cb) {
    this.subs.push(cb)
  }
  notify() {
    this.subs.forEach((cb) => cb())
  }
}
Dep.target = null


var demo = new Vue({
  el: '#demo',
  data: {
    text: "before",
    test: {
      a: '1'
    },
    t: 1
  },
  render() {
    return this.__h__('div', {}, [
      this.__h__('span', {}, [this.__toString__(this.text)]),
      this.__h__('span', {}, [this.__toString__(this.test.a)])
    ])
  }
})

vue react響應式簡單對比

綜上發現，利用Object.defineProperty這個特性可以精確的寫出訂閱釋出模式，從這點來說，vue是優於react的，在沒經過優化之前，vue的渲染機制一定是比react更加準確的，為了驗證這一說法，我用兩個框架同時寫了兩個相同的簡單專案進行對比。

沒有對比就沒有傷害：

通過對比發現，react在正常使用的過程中產生了多餘的渲染，在移動端或者元件巢狀非常深的情況下會產生非常大的效能消耗，因此在使用react的過程中，寫好react生命週期中的shouldComponentUpdate是非常重要的！

　參考