Explication détaillée de l'utilisation de vue+update()

Cette fois, je vais vous apporter une explication détaillée de l'utilisation de vue+update(), et quelles sont les précautions d'utilisation de vue+update(). Ce qui suit est un cas pratique, jetons un coup d'œil.

Préface

Il y a trois mois, j'ai lu le code source de vue pour analyser comment obtenir des données réactives. Le nom de l'article est le code source de vue pour les données réactives. analyse Après les modifications des données, la méthode update() de Watcher sera appelée. Continuons donc à voir ce que nous avons fait après trois mois (j'ai réalisé un projet avec React-Native au cours des trois derniers mois, et je n'en ai pas. intention de le résumer, car cela semble trop compliqué).

La méthode narrative de cet article est de suivre la logique de regarder le code source. La version de vue que j'ai vérifiée est la 2.5.2. a créé une copie du code source pour enregistrer les commentaires.

Objectif

Ce n'est qu'en clarifiant la direction de l'enquête que nous pourrons atteindre l'objectif. Parlons d'abord du comportement cible. : quelle méthode est exécutée pour mettre à jour la vue après les modifications des données. Préparez-vous ensuite à commencer dans cette direction. Le but est de trouver la réponse à partir de l'entrée du code source de la vue

Partez de la conclusion précédente.

Tout d'abord, passons en revue la conclusion précédente :

Lorsque la vue est construite, les données (et les objets Observer sont créés sur d'autres champs), les getters et les setters sont interceptés, les getters déclenchent la collecte de dépendances et setters trigger notify.

L'autre objet est Watcher, et l'objet watch sera appelé une fois lors de l'enregistrement d'une watch. Cela déclenche le getter de l'objet watch et collecte les dépendances dans les dépôts du Watcher actuel. le setter de n'importe quel dépôt est déclenché, le Watcher actuel sera averti d'appeler la méthode update() du Watcher

Ensuite, voici l'enregistrement du Watcher lié au rendu.

Le fichier. se trouve dans src/core/instance/lifecycle.js.

new Watcher(vm, updateComponent, noop, null, true /* isRenderWatcher */)

mountComponent

Rendu Le Watcher concerné est appelé dans la méthode mountComponent(), alors allons recherchez où cette méthode est appelée. Il n'y a que deux endroits, à savoir src/platforms/web/runtime/index.js et src/platforms/weex/ runtime/index.js, en prenant le web comme exemple :

Vue.prototype.$mount = function (
 el?: string | Element,
 hydrating?: boolean
): Component {
 el = el && inBrowser ? query(el) : undefined
 return mountComponent(this, el, hydrating)
}

Il s'avère que la méthode $mount() appelle mountComponent(), (ou spécifier le champ el lors de la construction de vue appellera également automatiquement la méthode $mount()), car les objets de rendu de web et weex (qu'est-ce que weex ? Je l'ai déjà présenté dans d'autres articles) sont différents, donc différents fichiers doivent être introduits lors de la publication et finalement différentes distes ne peuvent pas être publiées (ce problème est laissé pour plus tard. Étudions l'ensemble du processus de vue

). Voici la méthode mountComponent :

export function mountComponent (
 vm: Component,
 el: ?Element,
 hydrating?: boolean
): Component {
 vm.$el = el // 放一份el到自己的属性里
 if (!vm.$options.render) { // render应该经过处理了, 因为我们经常都是用template或者vue文件
 // 判断是否存在render函数, 如果没有就把render函数写成空VNode来避免红错, 并报出黄错
 vm.$options.render = createEmptyVNode
 if (process.env.NODE_ENV !== 'production') {
  /* istanbul ignore if */
  if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
  vm.$options.el || el) {
  warn(
   'You are using the runtime-only build of Vue where the template ' +
   'compiler is not available. Either pre-compile the templates into ' +
   'render functions, or use the compiler-included build.',
   vm
  )
  } else {
  warn(
   'Failed to mount component: template or render function not defined.',
   vm
  )
  }
 }
 }
 callHook(vm, 'beforeMount')
 let updateComponent
 /* istanbul ignore if */
 if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
 // 不看这里的代码了, 直接看else里的, 行为是一样的
 updateComponent = () => {
  const name = vm._name
  const id = vm._uid
  const startTag = `vue-perf-start:${id}`
  const endTag = `vue-perf-end:${id}`
  mark(startTag)
  const vnode = vm._render()
  mark(endTag)
  measure(`vue ${name} render`, startTag, endTag)
  mark(startTag)
  vm._update(vnode, hydrating)
  mark(endTag)
  measure(`vue ${name} patch`, startTag, endTag)
 }
 } else {
 updateComponent = () => {
  vm._update(vm._render(), hydrating)
 }
 }
 // we set this to vm._watcher inside the watcher's constructor
 // since the watcher's initial patch may call $forceUpdate (e.g. inside child
 // component's mounted hook), which relies on vm._watcher being already defined
 // 注册一个Watcher
 new Watcher(vm, updateComponent, noop, null, true /* isRenderWatcher */)
 hydrating = false
 // manually mounted instance, call mounted on self
 // mounted is called for render-created child components in its inserted hook
 if (vm.$vnode == null) {
 vm._isMounted = true
 callHook(vm, 'mounted')
 }
 return vm
}

Ce code ne fait en réalité que 3 choses :

• Appeler avant le hook Mount

• Créer un observateur

• Appeler le crochet monté

(hahaha) Ensuite, en fait, l'essentiel est d'établir un observateur.

Regardez les paramètres du Watcher : vm est-ce ceci, updateComponent est une fonction, noop est vide, null est vide et true signifie RenderWatcher.

Dans Watcher, j'ai regardé isRenderWatcher :

if (isRenderWatcher) {
  vm._watcher = this
 }

Oui, je viens de faire une copie pour juger de quelque chose lorsque le watcher patche pour la première fois (d'après les commentaires, je ne sais toujours pas à quoi ça sert) ).

Ensuite, il n'y en a qu'un problème qui reste non résolu, c'est ce qu'est updateComponent.

updateComponent

est passé dans le deuxième paramètre du constructeur de la fonction Watcher, puis cette fonction devient le getter de l'observateur. Si vous êtes intelligent, vous auriez dû deviner que les getters de toutes les données de la vue doivent être appelés dans ce updateComponent, afin que des dépendances puissent être établies dans l'observateur afin que la vue puisse répondre aux changements de données

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

Ensuite, allez dans vm._update() et vm._render().

J'ai trouvé la méthode ._render() dans src/core/instance/render.js.

Vue.prototype._render = function (): VNode {
 const vm: Component = this
 const { render, _parentVnode } = vm.$options // todo: render和_parentVnode的由来
 // reset _rendered flag on slots for duplicate slot check
 if (process.env.NODE_ENV !== 'production') {
  for (const key in vm.$slots) {
  // $flow-disable-line
  vm.$slots[key]._rendered = false
  }
 }
 if (_parentVnode) {
  vm.$scopedSlots = _parentVnode.data.scopedSlots || emptyObject
 }
 // set parent vnode. this allows render functions to have access
 // to the data on the placeholder node.
 vm.$vnode = _parentVnode
 // render self
 let vnode
 try {
  vnode = render.call(vm._renderProxy, vm.$createElement)
 } catch (e) {
  // catch其实不需要看了, 都是做异常处理, _vnode是在vm._update的时候保存的, 也就是上次的状态或是null(init的时候给的)
  handleError(e, vm, `render`)
  // return error render result,
  // or previous vnode to prevent render error causing blank component
  /* istanbul ignore else */
  if (process.env.NODE_ENV !== 'production') {
  if (vm.$options.renderError) {
   try {
   vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e)
   } catch (e) {
   handleError(e, vm, `renderError`)
   vnode = vm._vnode
   }
  } else {
   vnode = vm._vnode
  }
  } else {
  vnode = vm._vnode
  }
 }
 // return empty vnode in case the render function errored out
 if (!(vnode instanceof VNode)) {
  if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
  warn(
   'Multiple root nodes returned from render function. Render function ' +
   'should return a single root node.',
   vm
  )
  }
  vnode = createEmptyVNode()
 }
 // set parent
 vnode.parent = _parentVnode
 return vnode
 }
}

Cette méthode fait :

• Générer un VNode basé sur la méthode de rendu de la machine virtuelle actuelle (la méthode de rendu peut être compilée en fonction du modèle ou du fichier vue, donc elle on en déduit qu'écrire directement la méthode render est le plus efficace)

• S'il y a un problème avec la méthode render, appelez d'abord la méthode renderError, et si elle échoue, lisez le dernier vnode ou null.

• S'il existe un nœud parent, placez-le dans son propre attribut .parent.

• Enfin, renvoyez VNode

Donc, le noyau, c'est cette phrase :

vnode = render.call(vm._renderProxy, vm.$createElement)

Je ne sais pas ce que sont render(), vm._renderProxy, vm.$createElement.

先看vm._renderProxy: 是initMixin()的时候设置的, 在生产环境返回vm, 开发环境返回代理, 那么我们认为他是一个可以debug的vm(就是vm), 细节之后再看.

vm.$createElement的代码在vdom文件夹下, 看了下是一个方法, 返回值一个VNode.

render有点复杂, 能不能以后研究, 总之就是把template或者vue单文件和mount目标parse成render函数.

小总结: vm._render()的返回值是VNode, 根据当前vm的render函数

接下来看vm._update()

Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {
 const vm: Component = this
 if (vm._isMounted) {
  callHook(vm, 'beforeUpdate')
 }
 // 记录update之前的状态
 const prevEl = vm.$el
 const prevVnode = vm._vnode
 const prevActiveInstance = activeInstance
 activeInstance = vm
 vm._vnode = vnode
 // Vue.prototype.__patch__ is injected in entry points
 // based on the rendering backend used.
 if (!prevVnode) { // 初次加载, 只有_update方法更新vm._vnode, 初始化是null
  // initial render
  vm.$el = vm.__patch__( // patch创建新dom
  vm.$el, vnode, hydrating, false /* removeOnly */,
  vm.$options._parentElm,
  vm.$options._refElm
  )
  // no need for the ref nodes after initial patch
  // this prevents keeping a detached DOM tree in memory (#5851)
  vm.$options._parentElm = vm.$options._refElm = null
 } else {
  // updates
  vm.$el = vm.__patch__(prevVnode, vnode) // patch更新dom
 }
 activeInstance = prevActiveInstance
 // update __vue__ reference
 if (prevEl) {
  prevEl.__vue__ = null
 }
 if (vm.$el) {
  vm.$el.__vue__ = vm
 }
 // if parent is an HOC, update its $el as well
 if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
  vm.$parent.$el = vm.$el
 }
 // updated hook is called by the scheduler to ensure that children are
 // updated in a parent's updated hook.
 }

我们关心的部分其实就是__patch()的部分, __patch()做了对dom的操作, 在_update()里判断了是否是初次调用, 如果是的话创建新dom, 不是的话传入新旧node进行比较再操作.

结论

vue的视图渲染是一种特殊的Watcher, watch的内容是一个函数, 函数运行的过程调用了render函数, render又是由template或者el的dom编译成的(template中含有一些被observe的数据). 所以template中被observe的数据有变化触发Watcher的update()方法就会重新渲染视图.

遗留

render函数是在哪里被编译的
vue源码发布时引入不同平台最后打成dist的流程是什么
__patch__和VNode的分析

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

小程序开发分享页面后返回首页

vue-cli axios请求与跨域

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!