vue.js响应式原理

2021-02-28 本文已影响0人 lowpoint

vue2响应式原理主要通过 Object.fefineProperty

当把一个普通的js对象传入 Vue 实例作为 data 选项,Vue将遍历此对象所有的属性，并使用 Object.fefineProperty 把这些属性全部转为 getter/setter 。 Object.defineProperty 是ES5中一个无法 shim 的特性，这也是Vue 不支持IE8 以及更低版本浏览器的原因。

// 模拟 Vue 中的 data 选项
    let data = {
      msg: 'hello'
    }

    // 模拟 Vue 的实例
    let vm = {}

    // 数据劫持：当访问或者设置 vm 中的成员的时候，做一些干预操作
    Object.defineProperty(vm, 'msg', {
      // 可枚举（可遍历）
      enumerable: true,
      // 可配置（可以使用 delete 删除，可以通过 defineProperty 重新定义）
      configurable: true,
      // 当获取值的时候执行
      get () {
        console.log('get: ', data.msg)
        return data.msg
      },
      // 当设置值的时候执行
      set (newValue) {
        console.log('set: ', newValue)
        if (newValue === data.msg) {
          return
        }
        data.msg = newValue
        // 数据更改，更新 DOM 的值
        document.querySelector('#app').textContent = data.msg
      }
    })

    // 测试
    vm.msg = 'Hello World'

vue3响应式原理主要通过 Proxy 代理对象

直接监听对象，而非属性
ES6新增，IE不支持。

// 模拟 Vue 中的 data 选项
    let data = {
      msg: 'hello',
      count: 0
    }

    // 模拟 Vue 实例
    let vm = new Proxy(data, {
      // 执行代理行为的函数
      // 当访问 vm 的成员会执行
      get (target, key) {
        console.log('get, key: ', key, target[key])
        return target[key]
      },
      // 当设置 vm 的成员会执行
      set (target, key, newValue) {
        console.log('set, key: ', key, newValue)
        if (target[key] === newValue) {
          return
        }
        target[key] = newValue
        document.querySelector('#app').textContent = target[key]
      }
    })

发布订阅模式

订阅者
发布者
信号中心
存在一个信号中心，某个任务执行完成，就向信号中心发布一个信号，其它任务可以向信号中心订阅这个信号，从而知道什么时候可以开始执行任务。

// 事件触发器
    class EventEmitter {
      constructor () {
        // { 'click': [fn1, fn2], 'change': [fn] }
        this.subs = Object.create(null)
      }

      // 注册事件
      $on (eventType, handler) {
        this.subs[eventType] = this.subs[eventType] || []
        this.subs[eventType].push(handler)
      }

      // 触发事件
      $emit (eventType) {
        if (this.subs[eventType]) {
          this.subs[eventType].forEach(handler => {
            handler()
          })
        }
      }
    }

    // 测试
    let em = new EventEmitter()
    em.$on('click', () => {
      console.log('click1')
    })
    em.$on('click', () => {
      console.log('click2')
    })

    em.$emit('click')

观察者模式

观察者(订阅者) --watcher
update():当事件发生时，具体要做的事情
目标(发布者)
- subs数组：存储所有观察者
- addSub():添加观察者
- notify():当事件发生，调用所有观察者的 update() 方法
没有事件中心

// 发布者-目标
    class Dep {
      constructor () {
        // 记录所有的订阅者
        this.subs = []
      }
      // 添加订阅者
      addSub (sub) {
        if (sub && sub.update) {
          this.subs.push(sub)
        }
      }
      // 发布通知
      notify () {
        this.subs.forEach(sub => {
          sub.update()
        })
      }
    }
    // 订阅者-观察者
    class Watcher {
      update () {
        console.log('update')
      }
    }

    // 测试
    let dep = new Dep()
    let watcher = new Watcher()

    dep.addSub(watcher)

    dep.notify()

图片.png

手写一个简单的vue.js

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中的成员转换成getter和setter，注入到vue实例中
    this._proxyData(this.$data)
    // 3. 调用observer对象，监听数据的变化
    new Observer(this.$data)
    // 4. 调用compiler对象，解析指令和差值表达式
    new Compiler(this)
  }
  _proxyData (data) {
    // 遍历data中的所有属性
    Object.keys(data).forEach(key => {
      // 把data的属性注入到vue实例中
      Object.defineProperty(this, key, {
        enumerable: true,
        configurable: true,
        get () {
          return data[key]
        },
        set (newValue) {
          if (newValue === data[key]) {
            return
          }
          data[key] = newValue
        }
      })
    })
  }
}

Observer

将data选项中的属性转换成响应式数据
属性为对象嵌套也进行响应式处理
数据变化发送通知

class Observer{
  
  constructor(data){
    this.walk(data)
  }
  //遍历对象的所有属性
  walk(data){
    //1.判断data是否为对象
    if(!data || typeof data !== 'object') return 
    //2.遍历对象的所有属性
    Object.keys(data).forEach(key=>{
      this.defineReactive(data,key,data[key])
    })
  }
  //调用 Object.definePorperty 将属性转换为getter与setter
  //params:1.object 2.key 3.val
  defineReactive(obj,key,val){

    let that = this
    //收集依赖，并且发送通知
    let dep = new Dep()  //通过后面Dep类实现
    //val为对象 此时也要把val内部对象属性转为getter 与setter
    this.walk(val)

    Object.defineProperty(obj,key,{
      enumerable:true,
      configurable:true,
      get(){
        Dep.target && dep.addSub(Dep.target) //收集依赖
        return val
        //不返回 obj[key] 因为 obj[key] 会访问obj 一直出发get() 栈溢出
      },
      set(newval){
        if(newval === val) return 
        val = newval
        //新赋值
        that.walk(newval)
         //发送通知
        dep.notify() //通过后面dep类实现
      }
    })
  }
}

Compiler

负责编译模板，解析指令/差值表达式
负责页面的首次渲染
当数据变化后重新渲染视图

class Compiler {
  //传入vue实例
  constructor(vm) {
    this.el = vm.$el
    this.vm = vm

    this.compile(this.el)
  }
  //编译模板 处理文本与元素节点
  compile(el) {
    //遍历el中的所有节点
    let childNodes = el.childNodes
    Array.from(childNodes).forEach(node => {
      if (this.isTextNode(node)) {
        this.compileText(node) //处理文本节点
      } else if (this.isElementNode(node)) {
        this.compileElement(node)//处理元素节点
      }
      //判断当前节点 是否有子节点  如果有 递归处理
      if (node.childNodes && node.childNodes.length) {
        this.compile(node)
      }
    })
  }
  //编译元素节点 处理指令
  compileElement(node) {
    //遍历所有属性节点
    Array.from(node.attributes).forEach(attr => {
      //判断是否为指令
      let attrName = attr.name
      if (this.isDirective(attrName)) {
        //v-text -> text
        attrName = attrName.substr(2)
        let key = attr.value
        this.update(node, key, attrName)
      }
    })
  }

  update(node, key, attrname) {
    let fn = this[attrname + `Updater`]
    fn && fn.call(this, node, this.vm[key], key)
  }
  //处理v-text指令
  textUpdater(node, value, key) {
    node.textContent = value

    new Watcher(this.vm, key, newvalue => {
      node.textContent = newvalue
    })
  }
  //处理v-model
  modelUpdater(node, value, key) {
    node.value = value //表单元素赋值

    new Watcher(this.vm, key, newvalue => {
      node.value = newvalue
    })

    //实现双向绑定  对node绑定input事件
    node.addEventListener('input', () => {
      this.vm[key] = node.value
    })
  }
  //编译文本节点 处理差值表达式
  compileText(node) {
    let reg = /\{\{(.+?)\}\}/ //匹配差值表达式
    let value = node.textContent
    if (reg.test(value)) {
      let key = RegExp.$1.trim() //获取花括号中的变量名
      node.textContent = value.replace(reg, this.vm[key]) //将真实值替换

      //创建Watcher对象，当数据改变更新视图
      new Watcher(this.vm, key, newvalue => {
        node.textContent = newvalue
      })
    }
  }
  //判断元素属性是否是指令
  isDirective(attrName) {
    return attrName.startsWith('v-')
  }
  //判断节点是否是文本节点
  isTextNode(node) {
    return node.nodeType === 3
  }
  //判断节点是否是元素节点
  isElementNode(node) {
    return node.nodeType === 1
  }
}

Dep(Dependency)

收集依赖，添加观察者(watcher)
通知所有观察者

class Dep {
  constructor() {
    //存储所有观察者
    this.subs = []
  }
  //添加观察者
  addSub(sub) {
    if (sub && sub.update) {
      this.subs.push(sub)
    }
  }
  //发布通知
  notify() {
    this.subs.forEach(sub => {
      sub.update()
    })
  }
}

图片.png

Watcher

图片.png

当数据变化触发依赖，dep通知所有的 Watcher 实例更新视图
自身实例化的时候往 dep 对象添加自己

class Watcher {
  //实例 data中属性 回调函数
  constructor(vm, key, cb) {
    this.vm = vm
    //data中属性名称
    this.key = key
    //回调函数负责更新视图
    this.cb = cb

    //将 Watcher 对象记录在Dep类的静态属性 target
    Dep.target = this
    //触发 get 方法，在fet方法中调用addSub
    this.oldValue = vm[key] //vm[key]会访问 get() 将 watcher对象存放在 target 中

    Dep.target = null //防止重复添加
  }

  //数据发生变化的时候更新视图
  update() {
    let newValue = this.vm[this.key]
    if (this.oldValue === newValue) return
    this.cb(newValue)
  }
}

图片.png

Virtual DOM

虚拟dom就是用普通的js对象来描述 DOM 对象
真实dom成员复杂，虚拟dom可以用简洁的方式来表示实现真实dom,创建虚拟dom开销小。

虚拟 DOM 可以维护程序的状态，跟踪上一次的状态
通过比较前后两次状态差异更新真实 DOM
虚拟 DOM 可以只更新变化的DOM,之前的DOM重用不变
作用
维护视图和状态的关系
复杂视图情况下提升渲染性能
跨平台
- 浏览器平台渲染dom
- 服务端渲染SSR(Nuxt.js/Next.js)
- 原生应用(Weex/React Native)
- 小程序(mpvue/uni-app)等

虚拟dom库

Snabbdom
- vue2 内部使用的虚拟dom就是改造的Snabbdom
- 通过模块可以扩展
- 源码使用TypeScript开发
- 最快的Virtual DOM之一
Virtual-dom

Snabbdom

cnpm i snabbdom

import { init } from 'snabbdom/build/package/init'
import { h } from 'snabbdom/build/package/h'

const patch = init([])

// 第一个参数：标签+选择器
// 第二个参数：如果是字符串就是标签中的文本内容
let vnode = h('div#container.cls', {
  hook: {
     //钩子函数
    init(vnode) {
      console.log(vnode.elm)
    },
    create(emptyNode, vnode) {
      console.log(vnode.elm)
    }
  }
}, 'Hello World')

// 嵌套子元素
// let vnode = h('div#container', [
//   h('h1', 'Hello Snabbdom'),
//   h('p', '这是一个p')
// ])

let app = document.querySelector('#app')

// patch第一个参数：旧的 VNode，可以是 DOM 元素
// patch第二个参数：新的 VNode
// 返回新的 VNode
// patch对比两个vnode 将差异更新到真实node上

let oldVnode = patch(app, vnode)
// 清除div中的内容 
 // patch(oldVnode, h('!')) //空注释节点

Snabbdom 模块

Snabbdom 的核心库并不能处理DOM元素的属性/样式/事件等，可以通过注册 Snabbdom 默认提供的模块来实现
Snabbdom 中的模块可以用来扩展 Snabbdom 的功能
Snabbdom 中的模块的实现是通过注册全局的钩子函数来实现的
官方提供的模块
attributes(设置dom对象属性，setAttribute实现)
props（设置dom对象属性，通过对象.属性实现）
dataset(处理h5中 data- 自定义属性)
class(用来切换类样式)
style(设置行内样式)
eventlisteners(注册移除事件)

使用模块

导入需要的模块
init()中注册模块
h()函数的第二个参数处使用模块

Snabbdom 核心

init() 设置模块，创建 patch() 函数
使用h() 函数创建 JavaScript 对象（VNode）描述真实DOM
patch() 比较新旧两个 Vnode
把变化的内容更新到真实 DOM 树

patch 整体过程分析

patch(oldVnode,newVnode)
把新节点中变化的内容渲染到真实DOM,返回新节点作为下一次处理的旧节点
对比新旧VNode 是否相同节点(节点的key和sel相同)
如果不是相同节点，删除之前内容，重新渲染
如果是相同节点，再判断新的VNode是否有text,如果有并且和oldVnode的text不同，直接更新文本内容
如果新的VNode 有 children ,判断子节点是否有变化

vue.js响应式原理

发布订阅模式

观察者模式

手写一个简单的vue.js

Observer

Compiler

Dep(Dependency)

Watcher

Virtual DOM

Snabbdom

Snabbdom 模块

猜你喜欢

热点阅读