Vue의 가상 DOM에 대한 심층 분석

Virtual DOM 기술을 사용하면 페이지 렌더링의 효율성이 향상되어 노드 작업이 줄어들고 성능이 향상됩니다. 이 글에서는 vue의 Virtual DOM 기술 원리와 Vue 프레임워크의 구체적인 구현에 대한 심층 분석을 제공합니다. (학습 동영상 공유: vue 동영상 튜토리얼Virtual DOM的技术原理和 Vue 框架的具体实现。（学习视频分享：vue视频教程）

一、真实DOM和其解析流程

        本节我们主要介绍真实   DOM 的解析过程，通过介绍其解析过程以及存在的问题，从而引出为什么需要虚拟DOM。一图胜千言，如下图为 webkit 渲染引擎工作流程图

        所有的浏览器渲染引擎工作流程大致分为5步：创建        DOM 树 —> 创建 Style Rules -> 构建 Render 树 —> 布局 Layout -—> 绘制 Painting。

• 第一步，构建 DOM 树：用 HTML 分析器，分析 HTML 元素，构建一棵 DOM 树；
• 第二步，生成样式表：用 CSS 分析器，分析 CSS 文件和元素上的 inline 样式，生成页面的样式表；
• 第三步，构建 Render 树：将 DOM 树和样式表关联起来，构建一棵 Render 树（Attachment）。每个 DOM 节点都有 attach 方法，接受样式信息，返回一个 render 对象（又名 renderer），这些 render 对象最终会被构建成一棵 Render 树；
• 第四步，确定节点坐标：根据 Render 树结构，为每个 Render 树上的节点确定一个在显示屏上出现的精确坐标；
• 第五步，绘制页面：根据 Render 树和节点显示坐标，然后调用每个节点的 paint 方法，将它们绘制出来。

注意点：

1、DOM 树的构建是文档加载完成开始的？ 构建 DOM 树是一个渐进过程，为达到更好的用户体验，渲染引擎会尽快将内容显示在屏幕上，它不必等到整个 HTML 文档解析完成之后才开始构建 render 树和布局。

2、Render 树是 DOM 树和 CSS 样式表构建完毕后才开始构建的？ 这三个过程在实际进行的时候并不是完全独立的，而是会有交叉，会一边加载，一边解析，以及一边渲染。

3、CSS 的解析注意点？ CSS 的解析是从右往左逆向解析的，嵌套标签越多，解析越慢。

4、JS 操作真实 DOM 的代价？ 用我们传统的开发模式，原生 JS 或 JQ 操作 DOM 时，浏览器会从构建 DOM 树开始从头到尾执行一遍流程。在一次操作中，我需要更新 10 个 DOM 节点，浏览器收到第一个 DOM 请求后并不知道还有 9 次更新操作，因此会马上执行流程，最终执行10 次。例如，第一次计算完，紧接着下一个 DOM 更新请求，这个节点的坐标值就变了，前一次计算为无用功。计算 DOM 节点坐标值等都是白白浪费的性能。即使计算机硬件一直在迭代更新，操作 DOM 的代价仍旧是昂贵的，频繁操作还是会出现页面卡顿，影响用户体验

二、Virtual-DOM 基础

2.1、虚拟 DOM 的好处

        虚拟 DOM 就是为了解决浏览器性能问题而被设计出来的。如前，若一次操作中有 10 次更新 DOM 的动作，虚拟 DOM 不会立即操作 DOM，而是将这 10 次更新的 diff 内容保存到本地一个 JS 对象中，最终将这个 JS 对象一次性 attch 到 DOM 树上，再进行后续操作，避免大量无谓的计算量。所以，用 JS 对象模拟 DOM 节点的好处是，页面的更新可以先全部反映在 JS 对象(虚拟 DOM )上，操作内存中的 JS 对象的速度显然要更快，等更新完成后，再将最终的 JS 对象映射成真实的 DOM)

1. 실제 DOM 및 해당 구문 분석 프로세스

🎜 이 섹션에서는 주로 실제 를 소개합니다. >DOM 의 구문 분석 프로세스는 구문 분석 프로세스와 기존 문제를 소개함으로써 가상 DOM이 필요한 이유를 알려줍니다. 천 마디 말보다 한 장의 사진이 좋습니다. 아래 그림은 webkit 렌더링 엔진🎜

🎜🎜 모든 브라우저 렌더링 엔진 워크플로는 대략 5단계로 나뉩니다. DOM 트리 —> 스타일 규칙 생성 -> 렌더링 트리 빌드 —> 그림을 그립니다. 🎜

• 첫 번째 단계, DOM 트리 구축: HTML 파서를 사용하여 HTML 요소를 분석하고 DOM 트리 구축
• 두 번째 단계, 스타일 시트 생성: CSS 파서 사용, CSS 분석 페이지의 스타일 시트를 생성하기 위한 요소의 파일 및 인라인 스타일
• 세 번째 단계는 렌더 트리를 구축하는 것입니다. DOM 트리를 스타일 시트와 연결하여 렌더 트리(첨부 파일)를 구축합니다. 각 DOM 노드에는 스타일 정보를 받아들이고 렌더 객체(렌더러라고도 함)를 반환하는 연결 메소드가 있습니다. 이러한 렌더 객체는 결국 렌더 트리로 구성됩니다.
• 네 번째 단계는 노드 좌표: 렌더 트리 구조에 따라 렌더 트리의 각 노드에 대한 디스플레이에 나타나는 정확한 좌표를 결정합니다.
• 다섯 번째 단계는 페이지를 그리는 것입니다. 렌더 트리에 따라 좌표를 표시합니다. 트리와 노드를 호출한 다음 각각을 호출합니다. 노드의 페인트 메소드가 이를 그립니다.

🎜참고: 🎜🎜1. 문서가 로드될 때 DOM 트리 구성이 시작됩니까? DOM 트리 구축은 더 나은 사용자 경험을 달성하기 위해 점진적인 프로세스로, 렌더링 엔진은 가능한 한 빨리 콘텐츠를 화면에 표시합니다. 전체 HTML 렌더링 트리 및 레이아웃 구성은 문서 구문 분석이 완료된 후에만 시작됩니다. 🎜🎜2. DOM 트리와 CSS 스타일 시트가 빌드된 후에 렌더링 트리가 빌드됩니다. 이 세 가지 프로세스는 실제 구현에서 완전히 독립적이지는 않지만 동시에 중첩, 로드, 구문 분석 및 렌더링됩니다. 🎜🎜3. CSS를 구문 분석할 때 주의해야 할 점은 무엇인가요? CSS는 오른쪽에서 왼쪽으로 역으로 구문 분석됩니다. 중첩된 태그가 많을수록 구문 분석 속도가 느려집니다. 🎜🎜4. JS로 실제 DOM을 운영하는 데 드는 비용은 얼마인가요? 기존 개발 모델인 기본 JS 또는 JQ를 사용하여 DOM을 작동하는 경우 브라우저는 DOM 트리 구축부터 시작합니다. 스크래치를 사용하여 프로세스를 한 번 실행합니다. 한 작업에서 10개의 DOM 노드를 업데이트해야 합니다. 브라우저가 첫 번째 DOM 요청을 받은 후에는 9개의 업데이트 작업이 더 있다는 것을 알지 못합니다. 즉시 프로세스를 실행하고 최종적으로 10번 실행합니다. 예를 들어 첫 번째 계산 후 다음 DOM 업데이트 요청 직후 이 노드의 좌표 값이 변경되므로 이전 계산은 쓸모가 없습니다. DOM 노드 좌표 값 등을 계산하는 것은 성능 낭비입니다. 컴퓨터 하드웨어가 반복적으로 업데이트되었음에도 불구하고 DOM 운영 비용은 여전히 ​​높으며 빈번한 작업으로 인해 페이지가 정지되어 사용자 경험에 영향을 미치게 됩니다🎜

2. 가상 DOM 기본

2.1. 가상 DOM 이점

🎜 가상 DOM은 브라우저 성능 문제를 해결하도록 설계되었습니다. 이전과 마찬가지로 한 번의 작업으로 DOM을 업데이트하는 작업이 10개 있으면 가상 DOM은 DOM을 즉시 작동시키지 않고 10개를 업데이트합니다. times 업데이트된 diff 콘텐츠는 로컬 JS 개체에 저장되고 마지막으로 이 JS 개체는 attch에 저장됩니다. code>DOM 트리를 확인한 다음 불필요한 계산을 피하기 위해 후속 작업을 수행합니다. 따라서 JS 개체를 사용하여 DOM 노드를 시뮬레이션하면 모든 페이지 업데이트가 JS 개체(가상 DOM ), 메모리에서 <code>JS 객체를 작동하는 속도가 확실히 더 빨라졌습니다. 업데이트가 완료된 후 최종 JS 객체가 DOM 객체에 매핑됩니다. 실제 DOM은 브라우저에 맡겨져 그려집니다. 🎜

2.2. 알고리즘 구현

2.2.1. JS 객체를 사용하여 DOM 트리JS 对象模拟 DOM 树

（1）如何用 JS 对象模拟 DOM 树

例如一个真实的 DOM 节点如下：

<div>
<p>Virtual DOM</p>
<ul>
  <li>Item 1</li>
  <li>Item 2</li>
  <li>Item 3</li>
</ul>
<div>Hello World</div>
</div>

我们用 JavaScript 对象来表示 DOM 节点，使用对象的属性记录节点的类型、属性、子节点等。

element.js 中表示节点对象代码如下：

/**
 * Element virdual-dom 对象定义
 * @param {String} tagName - dom 元素名称
 * @param {Object} props - dom 属性
 * @param {Array<element>} - 子节点
 */
function Element(tagName, props, children) {
    this.tagName = tagName
    this.props = props
    this.children = children
    // dom 元素的 key 值，用作唯一标识符
    if(props.key){
       this.key = props.key
    }
    var count = 0
    children.forEach(function (child, i) {
        if (child instanceof Element) {
            count += child.count
        } else {
            children[i] = '' + child
        }
        count++
    })
    // 子元素个数
    this.count = count
}

function createElement(tagName, props, children){
 return new Element(tagName, props, children);
}

module.exports = createElement;</element>

根据 element 对象的设定，则上面的 DOM 结构就可以简单表示为：

var el = require("./element.js");
var ul = el('div',{id:'virtual-dom'},[  el('p',{},['Virtual DOM']),
  el('ul', { id: 'list' }, [	el('li', { class: 'item' }, ['Item 1']),
	el('li', { class: 'item' }, ['Item 2']),
	el('li', { class: 'item' }, ['Item 3'])
  ]),
  el('div',{},['Hello World'])
])

现在 ul 就是我们用  JavaScript 对象表示的 DOM 结构，我们输出查看 ul 对应的数据结构如下：

（2）渲染用 JS 表示的 DOM 对象

但是页面上并没有这个结构，下一步我们介绍如何将 ul 渲染成页面上真实的 DOM 结构，相关渲染函数如下：

/**
 * render 将virdual-dom 对象渲染为实际 DOM 元素
 */
Element.prototype.render = function () {
    var el = document.createElement(this.tagName)
    var props = this.props
    // 设置节点的DOM属性
    for (var propName in props) {
        var propValue = props[propName]
        el.setAttribute(propName, propValue)
    }

    var children = this.children || []
    children.forEach(function (child) {
        var childEl = (child instanceof Element)
            ? child.render() // 如果子节点也是虚拟DOM，递归构建DOM节点
            : document.createTextNode(child) // 如果字符串，只构建文本节点
        el.appendChild(childEl)
    })
    return el
}

我们通过查看以上 render 方法，会根据  tagName 构建一个真正的 DOM 节点，然后设置这个节点的属性，最后递归地把自己的子节点也构建起来。

我们将构建好的 DOM 结构添加到页面 body 上面，如下：

ulRoot = ul.render();
document.body.appendChild(ulRoot);

这样，页面 body 里面就有真正的 DOM 结构，效果如下图所示：

2.2.2、比较两棵虚拟 DOM 树的差异 — diff 算法

diff 算法用来比较两棵 Virtual DOM 树的差异，如果需要两棵树的完全比较，那么 diff 算法的时间复杂度为O(n^3)。但是在前端当中，你很少会跨越层级地移动 DOM 元素，所以 Virtual DOM 只会对同一个层级的元素进行对比，如下图所示， div 只会和同一层级的 div 对比，第二层级的只会跟第二层级对比，这样算法复杂度就可以达到 O(n)。

（1）深度优先遍历，记录差异

在实际的代码中，会对新旧两棵树进行一个深度优先的遍历，这样每个节点都会有一个唯一的标记：

在深度优先遍历的时候，每遍历到一个节点就把该节点和新的的树进行对比。如果有差异的话就记录到一个对象里面。

// diff 函数，对比两棵树
function diff(oldTree, newTree) {
  var index = 0 // 当前节点的标志
  var patches = {} // 用来记录每个节点差异的对象
  dfsWalk(oldTree, newTree, index, patches)
  return patches
}

// 对两棵树进行深度优先遍历
function dfsWalk(oldNode, newNode, index, patches) {
  var currentPatch = []
  if (typeof (oldNode) === "string" && typeof (newNode) === "string") {
    // 文本内容改变
    if (newNode !== oldNode) {
      currentPatch.push({ type: patch.TEXT, content: newNode })
    }
  } else if (newNode!=null && oldNode.tagName === newNode.tagName && oldNode.key === newNode.key) {
    // 节点相同，比较属性
    var propsPatches = diffProps(oldNode, newNode)
    if (propsPatches) {
      currentPatch.push({ type: patch.PROPS, props: propsPatches })
    }
    // 比较子节点，如果子节点有'ignore'属性，则不需要比较
    if (!isIgnoreChildren(newNode)) {
      diffChildren(
        oldNode.children,
        newNode.children,
        index,
        patches,
        currentPatch
      )
    }
  } else if(newNode !== null){
    // 新节点和旧节点不同，用 replace 替换
    currentPatch.push({ type: patch.REPLACE, node: newNode })
  }

  if (currentPatch.length) {
    patches[index] = currentPatch
  }
}

从以上可以得出，patches[1] 表示 p ，patches[3] 表示 ul ，以此类推。

（2）差异类型

DOM 操作导致的差异类型包括以下几种：

• 节点替换：节点改变了，例如将上面的 div 换成 h1;
• 顺序互换：移动、删除、新增子节点，例如上面 div 的子节点，把 p 和 ul 顺序互换；
• 属性更改：修改了节点的属性，例如把上面 li 的 class 样式类删除；
• 文本改变：改变文本节点的文本内容，例如将上面 p 节点的文本内容更改为 “Real Dom”；

以上描述的几种差异类型在代码中定义如下所示：

var REPLACE = 0 // 替换原先的节点
var REORDER = 1 // 重新排序
var PROPS = 2 // 修改了节点的属性
var TEXT = 3 // 文本内容改变

（3）列表对比算法

        子节点的对比算法，例如      p, ul, div 的顺序换成了 div, p, ul。这个该怎么对比？如果按照同层级进行顺序对比的话，它们都会被替换掉。如 p 和 div 的 tagName 不同，p 会被 div 所替代。最终，三个节点都会被替换，这样 DOM

를 시뮬레이션합니다. JS 개체는 DOM 트리를 시뮬레이션합니다. 🎜🎜

예를 들어 실제 DOM 노드는 다음과 같습니다. 🎜

var ul1 = el('div',{id:'virtual-dom'},[  el('p',{},['Virtual DOM']),
  el('ul', { id: 'list' }, [	el('li', { class: 'item' }, ['Item 1']),
	el('li', { class: 'item' }, ['Item 2']),
	el('li', { class: 'item' }, ['Item 3'])
  ]),
  el('div',{},['Hello World'])
]) 
var ul2 = el('div',{id:'virtual-dom'},[  el('p',{},['Virtual DOM']),
  el('ul', { id: 'list' }, [	el('li', { class: 'item' }, ['Item 21']),
	el('li', { class: 'item' }, ['Item 23'])
  ]),
  el('p',{},['Hello World'])
]) 
var patches = diff(ul1,ul2);
console.log('patches:',patches);

우리는 JavaScript code> 객체는 DOM 노드를 나타내며 객체의 속성을 사용하여 노드의 유형, 속성, 하위 노드 등을 기록합니다. 🎜

element.js는 노드 개체 코드를 다음과 같이 나타냅니다. 🎜

function patch (node, patches) {
  var walker = {index: 0}
  dfsWalk(node, walker, patches)
}

function dfsWalk (node, walker, patches) {
  // 从patches拿出当前节点的差异
  var currentPatches = patches[walker.index]

  var len = node.childNodes
    ? node.childNodes.length
    : 0
  // 深度遍历子节点
  for (var i = 0; i <p><code>element</code> 개체의 설정에 따라 위의 <code>DOM 구조는 다음과 같이 간단하게 표현할 수 있습니다. 🎜<div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">function applyPatches (node, currentPatches) {
  currentPatches.forEach(currentPatch => {
    switch (currentPatch.type) {
      case REPLACE:
        var newNode = (typeof currentPatch.node === 'string')
          ? document.createTextNode(currentPatch.node)
          : currentPatch.node.render()
        node.parentNode.replaceChild(newNode, node)
        break
      case REORDER:
        reorderChildren(node, currentPatch.moves)
        break
      case PROPS:
        setProps(node, currentPatch.props)
        break
      case TEXT:
        node.textContent = currentPatch.content
        break
      default:
        throw new Error('Unknown patch type ' + currentPatch.type)
    }
  })
}

로그인 후 복사

로그인 후 복사