全网整合营销服务商

营销型网站+SEO优化+关键词快排=一站式服务

免费咨询热线:15959292472

[公司网站seo方案设计论文]diff的对象是虚拟dom

  这次给大家带来diff的对象是虚拟dom,使用diff虚拟dom对象的注意事项有哪些▼△■,下面就是实战案例△◆▽,一起来看一下□▼•。

  

虚拟dom

  

diff算法首先要明确一个概念就是diff的对象是虚拟dom☆◇▪-,更新真实dom则是diff算法的结果

  

Vnode基类

  

 constructor (
 ▪…▷•。○▲•。…○-▲。
 ) {
 this.tag = tag
 this.data = data
 this.children = children
 this.text = text
 this.elm = elm
 this=◁●□.ns = undefined
 this.context = context
 this.fnContext = undefined
 this.fnOptions = undefined
 this•★.fnScopeId = undefined
 this.key = data && data▲◁○◇.key
 this.componentOptions = componentOptions
 this.componentInstance = undefined
 this.parent = undefined
 this●◁▽.raw = false
 this.isStatic = false
 this•-△▲.isRootInsert = true
 this.isComment = false
 this.isCloned = false
 this-•◁▷.isOnce = false
 this.asyncFactory = asyncFactory
 this◇△▽-.asyncMeta = undefined
 this.isAsyncPlaceholder = false
 }

这个部分的代码 主要是为了更好地知道在diff算法中具体diff的属性的含义,当然也可以更好地了解vnode实例

  

整体过程

  

核心函数是patch函数

  

  • isUndef判断(是不是undefined或者null)

      

  • // empty mount (likely as component)▲★-, create new root elementcreateElm(vnode, insertedVnodeQueue) 这里可以发现创建节点不是一个一个插入,而是放入一个队列中统一批处理

      

  • 核心函数sameVnode

      

function sameVnode (a••, b) {
 return (
 a.key === b.key &&•…★; (
 (
 a.tag === b▪☆▷.tag &&
 a◁•.isComment === b▷-.isComment &&
 isDef(a.data) === isDef(b.data) &□●△;&
 sameInputType(a•▲●, b)
 ) 

 

   ( isTrue(a.isAsyncPlaceholder) && a.asyncFactory === b.asyncFactory &◆○-;& isUndef(b□▷.asyncFactory•▪△◇.error) ) ) ) }

这里是一个外层的比较函数,直接去比较了两个节点的key◇☆,tag(标签)★●□▪,data的比较(注意这里的data指的是VNodeData)•■,input的话直接比较type。

  

export interface VNodeData {
 key?: string 

 

   number; slot?●•■▪: string; scopedSlots▷△◆•?: { [key▪○-: string]: ScopedSlot }…○☆; ref?☆•▽◇: string; tag▼☆=?: string; staticClass▽▷☆…?: string◇-○; class◆△▪□?: any☆◆; staticStyle?: { [key: string]◁◇●-: any }; style?: object[]

   object•◇▽=; props?: { [key: string]□☆: any }; attrs▼△?: { [key: string]: any }; domProps?: { [key△■▷◁: string]: any }; hook△■?: { [key……●△: string]: Function }; on?: { [key: string]…•: Function

   Function[] }; nativeOn?: { [key•▼: string]●△: Function

   Function[] }; transition◆=?☆■•▲: object; show□◁◁◁?: boolean▷◇; inlineTemplate★▪○★?: { render: Function; staticRenderFns: Function[]-▲; }; directives?: VNodeDirective[]; keepAlive?: boolean; }

这会确认两个节点是否有进一步比较的价值,不然直接替换

  

替换的过程主要是一个createElm函数 另外则是销毁oldVNode

  

// destroy old node
 if (isDef(parentElm)) {
 removeVnodes(parentElm, [oldVnode]◇▽-△, 0…◁●, 0)
 } else if (isDef(oldVnode■-▽.tag)) {
 invokeDestroyHook(oldVnode)
 }

插入过程简化来说就是判断node的type分别调用

  

createComponent(会判断是否有children然后递归调用)

  

createComment

  

createTextNode

  

创建后使用insert函数

  

之后需要用hydrate函数将虚拟dom和真是dom进行映射

  

function insert (parent, elm•△, ref) {
 if (isDef(parent)) {
 if (isDef(ref)) {
 if (ref.parentNode === parent) {
 nodeOps.insertBefore(parent=◇▪▷, elm, ref)
 }
 } else {
 nodeOps.appendChild(parent, elm)
 }
 }
 }

核心函数

  

 function patchVnode (oldVnode◆☆•, vnode, insertedVnodeQueue, removeOnly) {
 if (oldVnode === vnode) {
 return
 }
 const elm = vnode.elm = oldVnode◇▽▲=.elm
 if (isTrue(oldVnode☆●.isAsyncPlaceholder)) {
 if (isDef(vnode.asyncFactory.resolved)) {
 hydrate(oldVnode=▼.elm★◆•●, vnode…•…-, insertedVnodeQueue)
 } else {
 vnode.isAsyncPlaceholder = true
 }
 return
 }
 if (isTrue(vnode.isStatic) &&
 isTrue(oldVnode.isStatic) &&
 vnode…•.key === oldVnode○●◇.key &&
 (isTrue(vnode.isCloned) 

 

   isTrue(vnode.isOnce)) ) { vnode.componentInstance = oldVnode.componentInstance return } let i const data = vnode□▪•.data if (isDef(data) && isDef(i = data.hook) &&○★-; isDef(i = i.prepatch)) { i(oldVnode▲…, vnode) } const oldCh = oldVnode◁▼★▼.children const ch = vnode.children if (isDef(data) &&■=-; isPatchable(vnode)) { for (i = 0◆•□; i < cbs.update★▲□.length; ++i) cbs.update[i](oldVnode, vnode) if (isDef(i = data◁▼.hook) && isDef(i = i.update)) i(oldVnode, vnode) } if (isUndef(vnode.text)) { if (isDef(oldCh) && isDef(ch)) { if (oldCh •★!== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly) } else if (isDef(ch)) { if (isDef(oldVnode▲▲☆▼.text)) nodeOps☆•◁▼.setTextContent(elm, '▼▽;'★▽◆▲;) addVnodes(elm, null, ch, 0, ch▷•.length - 1, insertedVnodeQueue) } else if (isDef(oldCh)) { removeVnodes(elm, oldCh▪▲, 0, oldCh…☆.length - 1) } else if (isDef(oldVnode▼….text)) { nodeOps=★▲.setTextContent(elm▽○, '') } } else if (oldVnode.text !== vnode.text) { nodeOps◇○.setTextContent(elm, vnode▪▷▪▽.text) } if (isDef(data)) { if (isDef(i = data.hook) && isDef(i = i★•.postpatch)) i(oldVnode, vnode) } }

const el = vnode.el = oldVnode.el 这是很重要的一步▷=,让vnode.el引用到现在的真实dom●•●,当el修改时,vnode.el会同步变化。

  

  1. 比较二者引用是否一致

      

  2. 之后asyncFactory不知道是做什么的,所以这个比较看不懂

      

  3. 静态节点比较key,相同后也不做重新渲染,直接拷贝componentInstance(once命令在此生效)

      

  4. 如果vnode是文本节点或注释节点,但是vnode-□▼■.text != oldVnode.text时,只需要更新vnode.elm的文本内容就可以

      

  5. children的比较

      

  • 如果只有oldVnode有子节点☆◆☆,那就把这些节点都删除

      

  • 如果只有vnode有子节点,广丰县小程序开发哪家好那就创建这些子节点,这里如果oldVnode是个文本节点就把vnode-▷-.elm的文本设置为空字符串

      

  • 都有则updateChildren◇▼-,这个之后详述

      

  • 如果oldVnode和vnode都没有子节点,但是oldVnode是文本节点或注释节点,就把vnode.elm的文本设置为空字符串

      

updateChildren

  

这部分重点还是关注整个算法

  

首先四个指针,oldStart●◆•,oldEnd▼▼,newStart◆•◁,newEnd◁-▽•,两个数组◁•□,[渭南seo公司都选久澳]微信小程序中怎么让图片居中,oldVnode,Vnode。

  

function updateChildren (parentElm, oldCh, newCh•□, insertedVnodeQueue, removeOnly) {
 let oldStartIdx = 0
 let newStartIdx = 0
 let oldEndIdx = oldCh.length - 1
 let oldStartVnode = oldCh[0]
 let oldEndVnode = oldCh[oldEndIdx]
 let newEndIdx = newCh.length - 1
 let newStartVnode = newCh[0]
 let newEndVnode = newCh[newEndIdx]
 let oldKeyToIdx, idxInOld, vnodeToMove, refElm
 while (oldStartIdx <◇△-;= oldEndIdx && newStartIdx <= newEndIdx) {
 if (isUndef(oldStartVnode)) {
 oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
 } else if (isUndef(oldEndVnode)) {
 oldEndVnode = oldCh[--oldEndIdx]
 } else if (sameVnode(oldStartVnode, newStartVnode)) {
 patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue)
 oldStartVnode = oldCh[++oldStartIdx]
 newStartVnode = newCh[++newStartIdx]
 } else if (sameVnode(oldEndVnode, newEndVnode)) {
 patchVnode(oldEndVnode, newEndVnode▼◆▼◆, insertedVnodeQueue)
 oldEndVnode = oldCh[--oldEndIdx]
 newEndVnode = newCh[--newEndIdx]
 } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
 patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue)
 canMove && nodeOps-=-◇.insertBefore(parentElm, oldStartVnode.elm◁▼, nodeOps▪★.nextSibling(oldEndVnode.elm))
 oldStartVnode = oldCh[++oldStartIdx]
 newEndVnode = newCh[--newEndIdx]
 } else if (sameVnode(oldEndVnode◇●, newStartVnode)) { // Vnode moved left
 patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue)
 canMove &▲△▲;& nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
 oldEndVnode = oldCh[--oldEndIdx]
 newStartVnode = newCh[++newStartIdx]
 } else {
 if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
 idxInOld = isDef(newStartVnode.key)
 ? oldKeyToIdx[newStartVnode.key]
 ▷◆▪: findIdxInOld(newStartVnode☆▪▽◆, oldCh-▪, oldStartIdx, oldEndIdx)
 if (isUndef(idxInOld)) { // New element
 createElm(newStartVnode○=, insertedVnodeQueue, parentElm, oldStartVnode.elm△……, false, newCh▪☆•, newStartIdx)
 } else {
 vnodeToMove = oldCh[idxInOld]
 if (sameVnode(vnodeToMove, newStartVnode)) {
 patchVnode(vnodeToMove▪-, newStartVnode•●◇▽, insertedVnodeQueue)
 oldCh[idxInOld] = undefined
 canMove && nodeOps.insertBefore(parentElm■▲=, vnodeToMove.elm, oldStartVnode.elm)
 } else {
 // same key but different element. treat as new element
 createElm(newStartVnode▽▪▽▼, insertedVnodeQueue, parentElm, oldStartVnode.elm=◆◆•, false, newCh, newStartIdx)
 }
 }
 newStartVnode = newCh[++newStartIdx]
 }
 }
 if (oldStartIdx >-=; oldEndIdx) {
 refElm = isUndef(newCh[newEndIdx + 1]) ★◇•○? null ▲=▲▼: newCh[newEndIdx + 1].elm
 addVnodes(parentElm, refElm…○■, newCh◁▽, newStartIdx•◇☆, newEndIdx, insertedVnodeQueue)
 } else if (newStartIdx > newEndIdx) {
 removeVnodes(parentElm, oldCh, oldStartIdx▷▼△, oldEndIdx)
 }
 }

一个循环比较的几种情况和处理(以下的++ --均指index的++ --)比较则是比较的node节点,简略写法 不严谨 比较用的是sameVnode函数也不是真的全等

  

整体循环不结束的条件oldStartIdx <= oldEndIdx &&☆=; newStartIdx <◆□▷;= newEndIdx

  

  1. oldStart === newStart▪•○□,[公司网站seo方案设计论文]oldStart++ newStart++

      

  2. oldEnd === newEnd…●▽,海口市小程序制作公司oldEnd-- newEnd--

      

  3. oldStart === newEnd, oldStart插到队伍末尾 oldStart++ newEnd--

      

  4. oldEnd === newStart, oldEnd插到队伍开头 oldEnd-- newStart++

      

  5. 剩下的所有情况都走这个处理简单的说也就两种处理,处理后newStart++

      

  • newStart在old中发现一样的那么将这个移动到oldStart前

      

  • 没有发现一样的那么创建一个放到oldStart之前

      

循环结束后并没有完成

  

还有一段判断才算完

  

if (oldStartIdx > oldEndIdx) {
 refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
 addVnodes(parentElm●●, refElm=□■•, newCh, newStartIdx▽◆☆, newEndIdx, insertedVnodeQueue)
 } else if (newStartIdx > newEndIdx) {
 removeVnodes(parentElm•=, oldCh, oldStartIdx▷▲, oldEndIdx)
 }

简单的说就是循环结束后,看四个指针中间的内容,old数组中和new数组中,丹东市小程序制作公司多退少补而已

  

 

  相信看了本文案例你已经掌握了方法,更多精彩请关注久澳传媒编程栏目其它相关文章□◆!

  推荐阅读:

  JS的EventEmitter使用步奏详解
 

  怎么用Vue导出excel表格功能
 

  怎么在微信小程序里做出全局搜索代码高亮提醒

  以上就是diff的对象是虚拟dom的详细内容,更多请关注久澳传媒编程栏目其它相关文章!

[公司网站seo方案设计论文]diff的对象是虚拟dom

您的项目需求

*请认真填写需求信息,我们会在24小时内与您取得联系。