vue虚拟dom和diff算法

vue的虚拟dom和diff算法

1.虚拟dom

虚拟dom，我的理解就是通过js对象的方式来具体化每一个节点，把dom树上面的每个节点都变为对象里的一个元素，元素的子元素变为子节点，节点上面的class、id、attribute等属性变为data内的值，然后通过dom上面的createElement、appendChild、insertBefore等方法进行生成dom树。

let VNode = {
    sel:'div',
    data:{
        key:0,
        props:{},
        attrs:{},
        class:{},
        style:{},
        fn:{}
    },
    text:'虚拟dom',
    elm:'<div>虚拟dom</div>'
    children:[
        {
            sel:'div',
            data:{
                key:0,
                props:{},
                attrs:{},
                class:{},
                style:{},
                fn:{}
            },
            text:'虚拟dom children',
            elm:'<div>虚拟dom children</div>'
            children:[]
        }
    ]
}

 2.diff算法

看了diff算法后感觉写的真是巧妙，真正做到了最小量更新 。

diff是当父节点相同时用来对子节点进行最小量更新的算法。

diff算法采用四个指针：旧节点开始指针，旧节点结束指针，新节点开始指针，新节点结束指针；

（上方虚拟节点中的key就是为了在进行diff算法时判断是否是同一个节点便于最小量更新）

 

while(旧节点开始指针<=旧节点结束指针&&新节点开始指针<=新节点结束指针){

分为以下五种情况：（前四种情况）

「

  当进行下面5种判断后可能会出现新节点[新节点开始指针]   旧节点[旧节点开始指针]   新节点[新节点结束指针]   旧节点[旧节点结束指针]为空值的情况，如果出现空值则代表当前节点已经处理过了，所以就需要将指针++或者--

if(旧节点[旧节点开始指针] ==null){

旧节点开始指针++

}else if(旧节点[旧节点结束指针]==null){

旧节点结束指针--

}else if(新节点[新节点开始指针] ==null){

新节点开始指针++

}else if(新节点[新节点结束指针] ==null){

新节点结束指针--

}

」

1、新节点[新节点开始指针] 对比  旧节点[旧节点开始指针]

  如果符合此种情况，则代表新节点[新节点开始指针] 与 旧节点[旧节点开始指针] 为同一个节点，实行最小量更新，即只更新节点内的属性而不进行dom销毁创建操作，完成更新后 新节点开始指针++，旧节点开始指针++

2、新节点[新节点结束指针] 对比 旧节点[旧节点结束指针]

  如果符合此种情况，则代表新节点[新节点结束指针] 与 旧节点[旧节点结束指针] 为同一个节点，实行最小量更新，即只更新节点内的属性而不进行dom销毁创建操作，完成更新后 新节点结束指针--，旧节点结束指针--

3、新节点[新节点结束指针] 对比 旧节点[旧节点开始指针]

  如果符合此种情况，则代表新节点[新节点结束指针] 与 旧节点[旧节点开始指针] 为同一个节点，实行最小量更新，先更新节点内的属性，然后使用insertBefore将旧节点[旧节点开始指针] 移动到旧节点[旧节点结束指针] 之后，（注意：此处要移动到旧节点[旧节点结束节点] 后，而不是所有旧节点后，因为这里的旧节点结束指针是会变化的）,

    父节点.insertBefore(旧节点[旧节点开始指针].elm, 旧节点[旧节点结束指针].elm.nextSibling)

  完成操作后 新节点结束指针--，旧节点开始指针++

4、新节点[新节点开始指针] 对比 旧节点[旧节点结束指针] 如果符合此种情况，则代表新节点[新节点开始指针] 与 旧节点[旧节点结束指针] 为同一个节点，实行最小量更新，先更新节点内的属性，然后使用insertBefore将旧节点[旧节点结束指针] 移动到旧节点[旧节点开始指针] 前，（注意：此处要移动到旧节点[旧节点开始指针] 前，而不是所有旧节点前，因为旧节点开始指针也是会发生变化的）

    父节点.insertBefore(旧节点[旧节点结束指针].elm, 旧节点[旧节点开始指针].elm)

   完成操作后，旧节点结束指针--，新节点开始指针++

5、遍历旧节点数组，生成一个以key为键，index为值的对象为旧节点keyIndexMap，然后查询新节点[新节点开始指针]中的key是否在旧节点keyIndexMap中存在；

  如果不存在，则证明新节点[新节点开始指针]在旧节点列表中不存在，此时需要创建新节点[新节点开始指针]为真实dom，并将其插入至旧节点[旧节点开始指针]前(因为此时新节点[新节点开始指针]一定处于全部未处理的旧节点前)

父节点.insertBefore(创建dom(新节点[新节点开始指针]), 旧节点[旧节点开始指针].elm)

  如果存在则先需要判断旧节点[旧节点keyIndexMap[新节点[新节点开始指针][key]]]与新节点[新节点开始指针]的sel(标签)是否相同：

    如果相同则代表为同一个标签，则进行最小量更新，先更新节点内的属性，然后insertBefore将旧节点[旧节点keyIndexMap[新节点[新节点开始指针][key]]]移动到旧节点[旧节点开始指针] 前，然后将旧节点[旧节点keyIndexMap[新节点[新节点开始指针][key]]]设置为undefined，代表当前节点处理过了；

    如果不同则代表不是同一个标签，则只创建新节点[新节点开始指针]的真实dom，然后将其插入到旧节点[旧节点开始节点]。

  最后新节点开始指针++

}

当以上循环完成后可能还会出现没有处理到的节点，所以还需要再查找没有处理到的节点：

  如果是新节点开始指针<=新节点结束指针，则代表新节点列表内还有没有处理的节点，没有处理的节点全部为新增节点，此时需要遍历新节点[新节点开始指针]（包含）至新节点[新节点结束指针]（包含）之间的节点，然后将其添加至新节点[新节点结束指针+1]之前（新节点[新节点结束指针+1]可能为空，新节点[新节点结束指针+1]为空时可添加到最后）

        for (let i = 新节点开始节点; i <= 新节点结束节点; i++) {
          //insertBefore可以自动识别空值，如果是空值，则插入到最后
          父节点.insertBefore(创建dom(新节点[i]), 新节点[新节点结束节点-1]?.elm)
        }

   如果是旧节点开始指针<=旧节点结束指针，则代表旧节点内还有没有处理的节点，没有处理的节点全部为需要删除节点，此时需要遍历旧节点[旧节点开始指针]（包含）至旧节点[旧节点结束指针]（包含） 之间的节点，然后将其全部删除。

        for (let i = 旧节点开始指针; i <= 旧节点结束指针; i++) {
          旧节点[i] && (父节点.removeChild(旧节点[i].elm))
        }

 

以上就是我对diff算法的理解，下面贴上代码(阉割版，部分情况没有考虑，旨在学习diff算法，可能会有bug)：

//updateChildren文件
import { sameVnode } from './is'
import patchVnode from './patchVnode'
import createElement from './createElement'

export default functionupdateChildren  (parentElm, oldCh, newCh) {
  console.log('updateChildren')
  console.log(parentElm, oldCh, newCh)

  //旧前
  let oldStartIdx = 0
  //新前
  let newStartIdx = 0
  //旧后
  let oldEndIdx = oldCh.length - 1
  //新后
  let newEndIdx = newCh.length - 1
  //旧节点
  let oldStartVnode = oldCh[0]
  //旧后节点
  let oldEndVnode = oldCh[oldEndIdx]
  //新节点
  let newStartVnode = newCh[0]
  //新后节点
  let newEndVnode = newCh[newEndIdx]

  let keyMap = {}
//  开始循环
  while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
    // debugger
    console.log('while')
    if (oldStartVnode === undefined || oldCh[oldStartIdx] === undefined) {
      oldStartVnode = oldCh[++oldStartIdx]
    } else if (oldEndVnode === undefined || oldCh[oldEndIdx] === undefined) {
      oldEndVnode = oldCh[--oldEndIdx]
    } else if (newStartVnode === undefined || newCh[newStartIdx] === undefined) {
      newStartVnode = newCh[++newStartIdx]
    } else if (newEndVnode === undefined || newCh[newEndIdx] === undefined) {
      newEndVnode = newCh[--newEndIdx]
    } else if (sameVnode(oldStartVnode, newStartVnode)) {
      //新前和旧前是同一个节点
      console.log('新前和旧前是同一个节点')
      patchVnode(oldStartVnode, newStartVnode)
      oldStartVnode = oldCh[++oldStartIdx]
      newStartVnode = newCh[++newStartIdx]
    } else if (sameVnode(oldEndVnode, newEndVnode)) {//旧后和新后是同一个节点
      console.log('旧后和新后是同一个节点')
      patchVnode(oldEndVnode, newEndVnode)
      oldEndVnode = oldCh[--oldEndIdx]
      newEndVnode = newCh[--newEndIdx]
    } else if (sameVnode(oldStartVnode, newEndVnode)) {//新后和旧前是同一个节点
      console.log('新后和旧前是同一个节点')
      patchVnode(oldStartVnode, newEndVnode)
      //当新后节点是旧前节点时，此时需要移动节点，移动旧前节点到旧后的后面
      parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling)
      oldStartVnode = oldCh[++oldStartIdx]
      newEndVnode = newCh[--newEndIdx]
    } else if (sameVnode(oldEndVnode, newStartVnode)) {//旧后和新前是同一个节点
      console.log('旧后和新前是同一个节点')
      //  当旧后和新前是同一个节点时，此时需要移动旧后节点到旧前节点的前面
      patchVnode(oldEndVnode, newStartVnode)
      parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm)
      oldEndVnode = oldCh[--oldEndIdx]
      newStartVnode = newCh[++newStartIdx]
    } else {
      //前四种都没有命中
      if (Object.keys(keyMap).length === 0) {
        keyMap = {}
        for (let i = oldStartIdx; i <= oldEndIdx; i++) {
          const key = oldCh[i].key
          if (key) {
            keyMap[key] = i
          }
        }
      }
      console.log(keyMap)
      //寻找当前节点在keyMap中的位置
      const idxInOld = keyMap[newStartVnode.key]
      console.log(idxInOld)
      if (!idxInOld) {
        //新节点不在旧节点中
        parentElm.insertBefore(createElement(newStartVnode), oldStartVnode.elm)
      } else {
        //  新节点在旧节点中,需要移动
        const elmToMove = oldCh[idxInOld]
        if (elmToMove.sel !== newStartVnode.sel) {
          parentElm.insertBefore(createElement(newStartVnode), oldStartVnode.elm)
        } else {
          patchVnode(elmToMove, newStartVnode)
          //  把这项设置为undefined，表示已经移动过了
          oldCh[idxInOld] = undefined
          parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm)
        }
      }
      //指针向后移动
      newStartVnode = newCh[++newStartIdx]
    }
  }
// 继续查询是否有剩余节点
  if (newStartIdx <= newEndIdx) {
    console.log('新节点还有剩余节点没有处理', newStartIdx, newEndIdx)
    const before = newCh[newEndIdx + 1]?.elm
    console.log(before)
    for (let i = newStartIdx; i <= newEndIdx; i++) {
      //insertBefore可以自动识别undefined，如果是undefined，则插入到最后
      parentElm.insertBefore(createElement(newCh[i]), before)
    }
  } else if (oldStartIdx <= oldEndIdx) {
    console.log('旧节点还有剩余节点没有处理', oldStartIdx, oldEndIdx)
    for (let i = oldStartIdx; i <= oldEndIdx; i++) {
      oldCh[i] && (parentElm.removeChild(oldCh[i].elm))
    }
  }
}

let arr = [1, 1, 2, 35, 9, 2, 9]
arr.reduce((p, n) => {
  return p ^ n
}, 0)

 

//is文件
export function sameVnode (vnode1, vnode2) {
  return vnode1.sel === vnode2.sel && vnode1.key === vnode2.key;
}

//createElement文件
//真正创建dom
export default function createElement (vnode) {
  let domNode = document.createElement(vnode.sel);
  if (
    vnode.text !== "" &&
    (vnode.children === undefined || vnode.children.length === 0)
  ) {
    domNode.innerText = vnode.text;
    //  补充elm

  } else if (Array.isArray(vnode.children) && vnode.children.length > 0) {
    for (let i = 0; i < vnode.children.length; i++) {
      domNode.appendChild(createElement(vnode.children[i]));
    }
  }
  vnode.elm = domNode;
  return vnode.elm
}

//patchVnode文件
import createElement from './createElement'
import updateChildren from './updateChildren'

export default function patchVnode (oldVnode, newVnode) {
  // console.log('patchVnode')
  if (oldVnode === newVnode) return
  if (newVnode.text && (!newVnode.children || newVnode.children.length === 0)) {//判断newVnode的text是否为空，且不等于oldVnode的text，如果满足以上条件，则更新text
    oldVnode.text !== newVnode.text && (oldVnode.elm.innerText = newVnode.text);
  } else {//newVnode的text为空，则判断newVnode的children是否为空，如果不为空，则更新children
    //  新节点没有text属性
    if (oldVnode.children && oldVnode.children.length > 0) {
      //  老节点有children，新节点也有children
      updateChildren(oldVnode.elm, oldVnode.children, newVnode.children);
    } else {
      //  老的没有children，新的有children
      oldVnode.elm.innerHTML = '';
      for (let i = 0; i < newVnode.children.length; i++) {
        let dom = createElement(newVnode.children[i])
        oldVnode.elm.appendChild(dom)
      }
    }
  }
}

//patch文件
import vnode from "./vnode";
import createElement from "./createElement";
import patchVnode from './patchVnode'
import { sameVnode } from './is'

export default function (oldVnode, newVnode) {
  // console.log(oldVnode, newVnode)
  //判断传入的第一个参数，是dom节点还是vnode
  if (oldVnode.sel === "" || oldVnode.sel === undefined) {
    //传入的如果是dom节点需要包装为虚拟节点
    oldVnode = vnode(
      oldVnode.tagName.toLowerCase(),
      {},
      [],
      undefined,
      oldVnode,
    );
  }
  //  判断oldVnode和newVnode是否是同一个节点
  if (sameVnode(oldVnode, newVnode)) {
    // console.log("是同一个节点");
    patchVnode(oldVnode, newVnode);
  } else {
    // console.log("不是同一个节点");
    let newVnodeElm = createElement(newVnode, oldVnode.elm);
    if (oldVnode.elm.parentNode && newVnodeElm) {
      oldVnode.elm.parentNode.insertBefore(newVnodeElm, oldVnode.elm);
    }
    oldVnode.elm.parentNode.removeChild(oldVnode.elm);
  }
}

//VNode文件
export default function (sel, data, children, text, elm) {
  const key = data.key
  return {
    sel,
    data,
    children,
    text,
    elm,
    key,
  }
}

//h文件

import vnode from './vnode.js'

//h('div',{},'文字')
//h('div',{},'[]')
//h('div',{},h())
export default function (sel, data, c) {
//检查参数个数
  if (arguments.length !== 3) {
    throw new Error('h()参数个数不正确')

  }
//    检查C类型
  if (typeof c === 'string' || typeof c === 'number') {
    return vnode(sel, data, undefined, c, undefined)
  } else if (Array.isArray(c)) {
    let children = []
    for (let i = 0; i < c.length; i++) {
      if (!(typeof c[i] === 'object' && c[i].hasOwnProperty('sel'))) {
        throw new Error('传入的数组参数中有项不是h函数')
      }
      children.push(c[i])
    }
    //  循环结束，children收集完毕
    return vnode(sel, data, children, undefined, undefined)
  } else if (typeof c === 'object' && c.hasOwnProperty('sel')) {
    let children = [c]
    return vnode(sel, data, children, undefined, undefined)
  } else {
    throw new Error('h()参数类型不正确')
  }
}