Vue响应式原理的示例详解

2024-12-14 00:18:41

Vue 最独特的特性之一，是非侵入式的响应系统。数据模型仅仅是普通的 JavaScript 对象。而当你修改它们时，视图会进行更新。聊到 Vue 响应式实现原理，众多开发者都知道实现的关键在于利用 Object.defineProperty , 但具体又是如何实现的呢，今天我们来一探究竟。

为了通俗易懂，我们还是从一个小的示例开始：

<body>
  <div id="app">
    {{ message }}
  </div>
  <script>
    var app = new Vue({
      el: '#app',
      data: {
        message: 'Hello Vue!'
      }
    })
</script>
</body>

我们已经成功创建了第一个 Vue 应用！看起来这跟渲染一个字符串模板非常类似，但是 Vue 在背后做了大量工作。现在数据和 DOM 已经被建立了关联，所有东西都是响应式的。我们要怎么确认呢？打开你的浏览器的 JavaScript 控制台 (就在这个页面打开)，并修改 app.message的值，你将看到上例相应地更新。修改数据便会自动更新，Vue 是如何做到的呢？

通过 Vue 构造函数创建一个实例时，会有执行一个初始化的操作：

function Vue (options) {
    this._init(options);
}

这个 _init初始化函数内部会初始化生命周期、事件、渲染函数、状态等等：

initLifecycle(vm);
      initEvents(vm);
      initRender(vm);
      callHook(vm, 'beforeCreate');
      initInjections(vm);
      initState(vm);
      initProvide(vm);
      callHook(vm, 'created');

因为本文的主题是响应式原理，因此我们只关注 initState(vm) 即可。它的关键调用步骤如下：

function initState (vm) {
  initData(vm);
}

function initData(vm) {
  // data就是我们创建 Vue实例传入的 {message: 'Hello Vue!'}
  observe(data, true /* asRootData */);
}

function observe (value, asRootData) {
  ob = new Observer(value);
}

var Observer = function Observer (value) {
  this.walk(value);
}

Observer.prototype.walk = function walk (obj) {
  var keys = Object.keys(obj);
  for (var i = 0; i < keys.length; i++) {
    // 实现响应式关键函数
    defineReactive$$1(obj, keys[i]);
  }
};
}

我们来总结一下上面 initState(vm)流程。初始化状态的时候会对应用的数据进行检测，即创建一个 Observer 实例，其构造函数内部会执行原型上的 walk方法。walk方法的主要作用便是遍历数据的所有属性，并把每个属性转换成响应式，而这转换的工作主要由 defineReactive$$1 函数完成。

function defineReactive$$1(obj, key, val) {
  var dep = new Dep();
  Object.defineProperty(obj, key, {
    enumerable: true,
    configurable: true,
    get: function reactiveGetter() {
      var value = getter ? getter.call(obj) : val;
      if (Dep.target) {
        dep.depend();
        if (childOb) {
          childOb.dep.depend();
          if (Array.isArray(value)) {
            dependArray(value);
          }
        }
      }
      return value
    },
    set: function reactiveSetter(newVal) {
      var value = getter ? getter.call(obj) : val;
      /* eslint-disable no-self-compare */
      if (newVal === value || (newVal !== newVal && value !== value)) {
        return
      }
      /* eslint-enable no-self-compare */
      if (customSetter) {
        customSetter();
      }
      // #7981: for accessor properties without setter
      if (getter && !setter) { return }
      if (setter) {
        setter.call(obj, newVal);
      } else {
        val = newVal;
      }
      childOb = !shallow && observe(newVal);
      dep.notify();
    }
  });
}

defineReactive$$1函数内部使用Object.defineProperty 来监测数据的变化。每当从 obj 的 key 中读取数据时，get 函数被触发；每当往 obj 的 key 中设置数据时，set 函数被触发。我们说修改数据触发 set 函数，那么 set 函数是如何更新视图的呢？拿本文开头示例分析：

<div id="app">
    {{ message }}
</div>

该模板使用了数据 message, 当 message 的值发生改变的时候，应用中所有使用到 message 的视图都能触发更新。在 Vue 的内部实现中，先是收集依赖，即把用到数据 message 的地方收集起来，然后等数据发生改变的时候，把之前收集的依赖全部触发一遍就可以了。也就是说我们在上述的 get 函数中收集依赖，在 set 函数中触发视图更新。那接下来的重点就是分析 get 函数和 set 函数了。先看 get 函数，其关键调用如下：

get: function reactiveGetter () {
        if (Dep.target) {
          dep.depend();
        }
 }

Dep.prototype.depend = function depend () {
    if (Dep.target) {
      Dep.target.addDep(this);
    }
 };

Watcher.prototype.addDep = function addDep (dep) {
  dep.addSub(this);
}

 Dep.prototype.addSub = function addSub (sub) {
    this.subs.push(sub);
 };
 其中 Dep 构造函数如下：
 var Dep = function Dep () {
   this.id = uid++;
   this.subs = [];
 };

上述代码中Dep.target的值是一个Watcher实例，稍后我们再分析它是何时被赋值的。我们用一句话总结 get 函数所做的工作：把当前 Watcher 实例（也就是Dep.target）添加到 Dep 实例的 subs 数组中。在继续分析 get 函数前，我们需要弄清楚 Dep.target 的值何时被赋值为 Watcher 实例，这里我们需要从 mountComponent这个函数开始分析：

function mountComponent (vm, el, hydrating) {
  updateComponent = function () {
    vm._update(vm._render(), hydrating);
  };
  new Watcher(vm, updateComponent, noop, xxx);
}
// Wather构造函数下
var Watcher = function Watcher (vm, expOrFn, cb) {
  if (typeof expOrFn === 'function') {
    this.getter = expOrFn;
  } else {
    this.getter = parsePath(expOrFn);
  }
   this.value = this.get();
}

Watcher.prototype.get = function get () {
   pushTarget(this);
   value = this.getter.call(vm, vm);
}

function pushTarget (target) {
    targetStack.push(target);
    Dep.target = target;
}

由上述代码我们知道mountComponent函数会创建一个 Watcher 实例，在其构造函数中最终会调用 pushTarget函数，把当前 Watcher 实例赋值给 Dep.target。另外我们注意到，创建 Watcher 实例这个动作是发生在函数mountComponent内部，也就是说 Watcher 实例是组件级别的粒度，而不是说任何用到数据的地方都新建一个 Watcher 实例。现在我们再来看看 set 函数的主要调用过程：

set: function reactiveSetter (newVal) {
  dep.notify();
}

Dep.prototype.notify = function notify () {
   var subs = this.subs.slice();
   for (var i = 0, l = subs.length; i < l; i++) {
      subs[i].update();
    }
}

Watcher.prototype.update = function update () {
  queueWatcher(this);
}

 Watcher.prototype.update = function update () {
   // queue是一个全局数组
   queue.push(watcher);
   nextTick(flushSchedulerQueue);
 }

 // flushSchedulerQueue是一个全局函数
 function flushSchedulerQueue () {
    for (index = 0; index < queue.length; index++) {
      watcher = queue[index];
      watcher.run();
    }
 }

Watcher.prototype.run = function run () {
   var value = this.get();
}

set 函数内容有点长，但上述代码都是精简过的，应该不难理解。当改变应用数据的时候，触发 set 函数执行。它会调用 Dep 实例的 notify()方法，而 notify 方法又会把当前 Dep 实例收集的所有 Watcher 实例的 update 方法调用一遍，以达到更新所有用到该数据的视图部分。我们继续看 Watcher 实例的 update 方法做了什么。update 方法会把当前的 watcher 添加到数组 queue 中，然后把 queue 中每个 watcher 的 run 方法执行一遍。run 方法内部会执行 Wather 原型上的 get 方法，后续的调用在前文分析 mountComponent 函数中都有描述，在此就不再赘述。总结来说，最终 update 方法会触发 updateComponent函数：

updateComponent = function () {
  vm._update(vm._render(), hydrating);
};

Vue.prototype._update = function (vnode, hydrating) {
  vm.$el = vm.__patch__(prevVnode, vnode);
}

这里我们注意到 _update 函数的第一个参数是 vnode 。vnode 顾名思义是虚拟节点的意思，它是一个普通对象，该对象的属性上保存了生成 DOM 节点所需要数据。说到虚拟节点你是不是很容易就联想到虚拟 DOM 了呢，没错 Vue 中也使用了虚拟 DOM。前文说到 Wather 是和组件相关的，组件内部的更新就用虚拟 DOM 进行对比和渲染。_update 函数内部调用了 patch 函数，通过该函数对比新旧两个 vnode 之间的不同，然后根据对比结果找出需要更新的节点进行更新。

注：本文分析示例基于 Vue v2.6.14 版本。

到此这篇关于Vue响应式原理的示例详解的文章就介绍到这了,更多相关Vue响应式原理内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

详解Vue3的响应式原理解析

目录 Vue2响应式原理回顾 Vue3响应式原理剖析嵌套对象响应式避免重复代理总结 Vue2响应式原理回顾 // 1.对象响应化:遍历每个key,定义getter.setter // 2.数组响应化:覆盖数组原型方法,额外增加通知逻辑 const originalProto = Array.prototype const arrayProto = Object.create(originalProto) ;['push', 'pop', 'shift', 'unshift', 'splic
Vue响应式系统的原理详解

目录 vue响应式系统的基本原理 1.回顾一下Object.defineProperty的用法 2.实战1:使用 Object.defineProperty 对 person的age属性进行监听 3.数据代理 4.vue中实现响应式思路总结 1.Vue中的数据代理: 2.Vue中数据代理的好处: 3.基本原理: 4.vue中实现响应式思路 vue响应式系统的基本原理我们使用vue时,对数据进行操作,就能影响对应的视图.那么这种机制是怎么实现的呢? 思考一下,是不是就好像我们对数据的操作被
详解VUE响应式原理

目录 1.响应式原理基础 2.核心对象:Dep与Watcher 3.收集依赖与更新依赖 3.1 收集依赖 3.2 更新依赖 4.源码调试 4.1 测试的页面代码 1.对象说明 2.Dep与Watcher的关系 3.最终的关系结果 4.2 源码调试 1.收集依赖的入口函数:initState(页面初始化时执行); 2.初始化computed和watch时,生成Watcher实例化对象总结 1.响应式原理基础响应式基本原理是基于Object.defineProperty(obj, prop,
一起来看看Vue的核心原理剖析

目录前言: 学习目标: Object.defineProperty get.set 数据反应到视图视图的变化反映到数据 M -> V V -> M 优化工作: 总结前言: 相信大家阅读过很多关于Vue2的文章,我也阅读过很多,但是大部分文章介绍的都是如何在项目中进行应用,技术点如果使用,功能如何实现: 今天小编为大家带来这篇Vue2的核心原理剖析就是为大家介绍我们常用的Vue2他是如何实现的核心内容,我们简单代码的背后究竟他做了哪些,让大家能够知其然,知其所以然学习目标: 了解Obj
Vue的底层原理你了解多少

Observer (数据劫持) 核心是通过Obeject.defineProperty()来监听数据的变动,这个函数内部可以定义setter和getter.每当数据发生变化,就会触发setter().这时候 Observer 就要通过 Dep 通知 Watcher 订阅者. Dep (发布者) 有 addWatcher() 和 notify() 两个方法,(收集 Watcher 依赖,并通知依赖变更). Dep 保存多个 atcher,当 Dep 发现 Observer 有更新时,Dep 会调用
Vue响应式原理的示例详解

Vue 最独特的特性之一,是非侵入式的响应系统.数据模型仅仅是普通的 JavaScript 对象.而当你修改它们时,视图会进行更新.聊到 Vue 响应式实现原理,众多开发者都知道实现的关键在于利用 Object.defineProperty , 但具体又是如何实现的呢,今天我们来一探究竟. 为了通俗易懂,我们还是从一个小的示例开始: <body> <div id="app"> {{ message }} </div> <script> v
VUE响应式原理的实现详解

目录总结前言相信vue学习者都会发现,vue使用起来上手非常方便,例如双向绑定机制,让我们实现视图.数据层的快速同步,但双向绑定机制实现的核心数据响应的原理是怎么样的呢,接下来让我们开始介绍: function observer(value) { //给所有传入进来的data 设置一个__ob__对象一旦value有__ob__ 说明该value已经做了响应式处理 Object.defineProperty(value, '__ob__', { value: this, //当前实例也
Vue响应式原理及双向数据绑定示例分析

目录前言响应式原理双向数据绑定前言之前公司招人,面试了一些的前端同学,因为公司使用的前端技术是Vue,所以免不了问到其响应式原理和Vue的双向数据绑定.但是这边面试到的80%的同学会把两者搞混,通常我要是先问响应式原理再问双向数据绑定原理,来面试的同学大都会认为是一回事,那么这里我们就说一下二者的区别. 响应式原理是Vue的核心特性之一,数据驱动视图,我们修改数据视图随之响应更新,就很优雅~ Vue2.x是借助Object.defineProperty()实现的,而Vue3.x是借助
epoll封装reactor原理剖析示例详解

目录 reactor是什么? reactor模型三个重要组件与流程分析组件流程将epoll封装成reactor事件驱动封装每一个连接sockfd变成ntyevent 封装epfd和ntyevent变成ntyreactor 封装读.写.接收连接等事件对应的操作变成callback 给每个客户端的ntyevent设置属性将ntyevent加入到epoll中由内核监听将ntyevent从epoll中去除读事件回调函数写事件回调函数接受新连接事件回调函数 reactor运行 react
vue选项卡Tabs组件实现示例详解

目录概述效果图实现过程组件分析所需的前置知识项目组件文件夹 Tabs.vue TabPane.vue render.js index.js 使用总结概述前端项目中,多数页面涉及到选项卡切换,包括路由切换,指令v-if等,本质上其实和选项卡切换思想差不多,如果是个简单的选项卡,还是很简单的,我们也不需要什么组件库的组件,自己也能几行代码写出来,但是涉及到动画,尺寸计算,拖拽的功能的时候,多数情况下,自己写还是要花点时间的,组件库就提供了现成的,拿来改改样式就行,为了对这个组件更加
vue组合式API浅显入门示例详解

目录正文组合式API setup 变量声明目前比起选项式API的优点生命周期正文在react推出了hook之后,vue也在vue3里面添加了组合式API,鉴于这个时间间隔,我有理由认为组合式api和hook还是有一些关系的.不过在我具体的使用中,我并没发现这两个方法太多的相同点,不过鉴于vue自动发布之后就与react之间那剪不断理还乱的量子力学关系,估计会有很多人会问及这俩之间的异同.我还没到能分辨出异同的地步,就简单的介绍一下vue的组合式API吧. 组合式API 在vue3.0
vue 之 .sync 修饰符示例详解

在一些情况下,我们可能会需要对一个 prop (父子组件传递数据的属性) 进行"双向绑定". 在vue 1.x 中的 .sync 修饰符所提供的功能.当一个子组件改变了一个带 .sync 的prop的值时,这个变化也会同步到父组件中所绑定的值. 这很方便,但也会导致问题,因为它破坏了单向数据流.(数据自上而下流,事件自下而上走) 由于子组件改变 prop 的代码和普通的状体改动代码毫无区别,所以当你光看子组件的代码时,你完全不知道它合适悄悄地改变了父组件的状态. 这在 debug 复杂
java中Servlet监听器的工作原理及示例详解

监听器就是一个实现特定接口的普通java程序,这个程序专门用于监听另一个java对象的方法调用或属性改变,当被监听对象发生上述事件后,监听器某个方法将立即被执行. 监听器原理监听原理 1.存在事件源 2.提供监听器 3.为事件源注册监听器 4.操作事件源,产生事件对象,将事件对象传递给监听器,并且执行监听器相应监听方法监听器典型案例:监听window窗口的事件监听器例如:swing开发首先制造Frame**窗体**,窗体本身也是一个显示空间,对窗体提供监听器,监听窗体方法调用或者属性改变:
vue响应式原理与双向数据的深入解析

了解object.defineProperty 实现响应式清楚 observe/watcher/dep 具体指的是什么了解发布订阅模式以及其解决的具体问题在Javascript里实现数据响应式一般有俩种方案,分别对应着vue2.x 和 vue3.x使用的方式,他们分别是: 对象属性拦截 (vue2.x) Object.defineProperty 对象整体代理 (vue3.x) Proxy 提示:以下是本篇文章正文内容,下面案例可供参考 vue-响应式是什么? Vue 最独特的特性之一
Go底层channel实现原理及示例详解

目录概念: 使用场景: 底层数据结构: 操作: 创建发送接收关闭案例分析: 概念: Go中的channel 是一个队列,遵循先进先出的原则,负责协程之间的通信(Go 语言提倡不要通过共享内存来通信,而要通过通信来实现内存共享,CSP(Communicating Sequential Process)并发模型,就是通过 goroutine 和 channel 来实现的) 使用场景: 停止信号监听定时任务生产方和消费方解耦控制并发数底层数据结构: 通过var声明或者make函数创建

Vue响应式原理的示例详解

相关推荐

随机推荐