众所周知，对前端而言，直接操作 DOM 是一件及其耗费性能的事情，以 React 和 Vue 为代表的众多框架普遍采用 Virtual DOM 来解决如今愈发复杂 Web 应用中状态频繁发生变化导致的频繁更新 DOM 的性能问题。本文为笔者通过实际操作，实现了一个非常简单的 Virtual DOM ，加深对现今主流前端框架中 Virtual DOM 的理解。

关于 Virtual DOM ，社区已经有许多优秀的文章，而本文是笔者采用自己的方式，并有所借鉴前辈们的实现，以浅显易懂的方式，对 Virtual DOM 进行简单实现，但不包含snabbdom的源码分析，在笔者的最终实现里，参考了snabbdom的原理，将本文的Virtual DOM实现进行了改进，感兴趣的读者可以阅读上面几篇文章，并参考笔者本文的最终代码进行阅读。

本文阅读时间约15~20分钟。

概述

本文分为以下几个方面来讲述极简版本的 Virtual DOM 核心实现：

Virtual DOM 主要思想
用 JavaScript 对象表示 DOM 树
将 Virtual DOM 转换为真实 DOM
- 设置节点的类型
- 设置节点的属性
- 对子节点的处理
处理变化
- 新增与删除节点
- 更新节点
- 更新子节点

Virtual DOM 主要思想

要理解 Virtual DOM 的含义，首先需要理解 DOM ，DOM 是针对 HTML 文档和 XML 文档的一个 API ， DOM 描绘了一个层次化的节点树，通过调用 DOM API，开发人员可以任意添加，移除和修改页面的某一部分。而 Virtual DOM 则是用 JavaScript 对象来对 Virtual DOM 进行抽象化的描述。Virtual DOM 的本质是JavaScript对象，通过 Render函数，可以将 Virtual DOM 树映射为真实 DOM 树。

一旦 Virtual DOM 发生改变，会生成新的 Virtual DOM ，相关算法会对比新旧两颗 Virtual DOM 树，并找到他们之间的不同，尽可能地通过最少的 DOM 操作来更新真实 DOM 树。

我们可以这么表示 Virtual DOM 与 DOM 的关系：DOM = Render(Virtual DOM)。

用 JavaScript 对象表示 DOM 树

Virtual DOM 是用 JavaScript 对象表示，并存储在内存中的。主流的框架均支持使用 JSX 的写法， JSX 最终会被 babel 编译为JavaScript 对象，用于来表示Virtual DOM，思考下列的 JSX：

<div>
    <span className="item">item</span>
    <input disabled={true} />
</div>

最终会被babel编译为如下的 JavaScript对象：

{
    type: 'div',
    props: null,
    children: [{
        type: 'span',
        props: {
            class: 'item',
        },
        children: ['item'],
    }, {
        type: 'input',
        props: {
            disabled: true,
        },
        children: [],
    }],
}

我们可以注意到以下两点：

所有的 DOM 节点都是一个类似于这样的对象：

{ type: '...', props: { ... }, children: { ... }, on: { ... } }

本文节点是用 JavaScript 字符串来表示

那么 JSX 又是如何转化为 JavaScript 对象的呢。幸运的是，社区有许许多多优秀的工具帮助我们完成了这件事，由于篇幅有限，本文对这个问题暂时不做探讨。为了方便大家更快速地理解 Virtual DOM ，对于这一个步骤，笔者使用了开源工具来完成。著名的 babel 插件babel-plugin-transform-react-jsx帮助我们完成这项工作。

为了更好地使用babel-plugin-transform-react-jsx，我们需要搭建一下webpack开发环境。具体过程这里不做阐述，有兴趣自己实现的同学可以到simple-virtual-dom查看代码。

对于不使用 JSX 语法的同学，可以不配置babel-plugin-transform-react-jsx，通过我们的vdom函数创建 Virtual DOM：

function vdom(type, props, ...children) {
    return {
        type,
        props,
        children,
    };
}

然后我们可以通过如下代码创建我们的 Virtual DOM 树：

const vNode = vdom('div', null,
    vdom('span', { class: 'item' }, 'item'),
    vdom('input', { disabled: true })
);

在控制台输入上述代码，可以看到，已经创建好了用 JavaScript对象表示的 Virtual DOM 树：

将 Virtual DOM 转换为真实 DOM

现在我们知道了如何用 JavaScript对象来代表我们的真实 DOM 树，那么， Virtual DOM 又是怎么转换为真实 DOM 给我们呈现的呢？

在这之前，我们要先知道几项注意事项：

在代码中，笔者将以$开头的变量来表示真实 DOM 对象；
toRealDom函数接受一个 Virtual DOM 对象为参数，将返回一个真实 DOM 对象；
mount函数接受两个参数：将挂载 Virtual DOM 对象的父节点，这是一个真实 DOM 对象，命名为$parent；以及被挂载的 Virtual DOM 对象vNode；

下面是toRealDom的函数原型：

function toRealDom(vNode) {
    let $dom;
    // do something with vNode
    return $dom;
}

通过toRealDom方法，我们可以将一个vNode对象转化为一个真实 DOM 对象，而mount函数通过appendChild，将真实 DOM 挂载：

function mount($parent, vNode) {
    return $parent.appendChild(toRealDom(vNode));
}

下面，让我们来分别处理vNode的type、props和children。

设置节点的类型

首先，因为我们同时具有字符类型的文本节点和对象类型的element节点，需要对type做单独的处理：

if (typeof vNode === 'string') {
    $dom = document.createTextNode(vNode);
} else {
    $dom = document.createElement(vNode.type);
}

在这样一个简单的toRealDom函数中，对type的处理就完成了，接下来让我们看看对props的处理。

设置节点的属性

我们知道，如果节点有props，那么props是一个对象。通过遍历props，调用setProp方法，对每一类props单独处理。

if (vNode.props) {
    Object.keys(vNode.props).forEach(key => {
        setProp($dom, key, vNode.props[key]);
    });
}

setProp接受三个参数：

$target，这是一个真实 DOM 对象，setProp将对这个节点进行 DOM 操作；
name，表示属性名；
value，表示属性的值；

读到这里，相信你已经大概清楚setProp需要做什么了，一般情况下，对于普通的props，我们会通过setAttribute给 DOM 对象附加属性。

function setProp($target, name, value) {
    return $target.setAttribute(name, value);
}

但这远远不够，思考下列的 JSX 结构：

<div>
    <span className="item" data-node="item" onClick={() => console.log('item')}>item</span>
    <input disabled={true} />
</div>

从上面的 JSX 结构中，我们发现以下几点：

由于class是 JavaScript 的保留字， JSX 一般使用className来表示 DOM 节点所属的class；
一般以on开头的属性来表示事件；
除字符类型外，属性还可能是布尔值，如disabled，当该值为true时，则添加这一属性；

所以，setProp也同样需要考虑上述情况：

function isEventProp(name) {
    return /^on/.test(name);
}

function extractEventName(name) {
    return name.slice(2).toLowerCase();
}

function setProp($target, name, value) {
    if (name === 'className') { // 因为class是保留字，JSX使用className来表示节点的class
        return $target.setAttribute('class', value);
    } else if (isEventProp(name)) { // 针对 on 开头的属性，为事件
        return $target.addEventListener(extractEventName(name), value);
    } else if (typeof value === 'boolean') { // 兼容属性为布尔值的情况
        if (value) {
            $target.setAttribute(name, value);
        }
        return $target[name] = value;
    } else {
        return $target.setAttribute(name, value);
    }
}

最后，还有一类属性是我们的自定义属性，例如主流框架中的组件间的状态传递，即通过props来进行传递的，我们并不希望这一类属性显示在 DOM 中，因此需要编写一个函数isCustomProp来检查这个属性是否是自定义属性，因为本文只是为了实现 Virtual DOM 的核心思想，为了方便，在本文中，这个函数直接返回false。

function isCustomProp(name) {
    return false;
}

最终的setProp函数：

function setProp($target, name, value) {
    if (isCustomProp(name)) {
        return;
    } else if (name === 'className') { // fix react className
        return $target.setAttribute('class', value);
    } else if (isEventProp(name)) {
        return $target.addEventListener(extractEventName(name), value);
    } else if (typeof value === 'boolean') {
        if (value) {
            $target.setAttribute(name, value);
        }
        return $target[name] = value;
    } else {
        return $target.setAttribute(name, value);
    }
}

对子节点的处理

对于children里的每一项，都是一个vNode对象，在进行 Virtual DOM 转化为真实 DOM 时，子节点也需要被递归转化，可以想到，针对有子节点的情况，需要对子节点以此递归调用toRealDom，如下代码所示：

if (vNode.children && vNode.children.length) {
    vNode.children.forEach(childVdom => {
        const realChildDom = toRealDom(childVdom);
        $dom.appendChild(realChildDom);
    });
}

最终完成的toRealDom如下：

function toRealDom(vNode) {
    let $dom;
    if (typeof vNode === 'string') {
        $dom = document.createTextNode(vNode);
    } else {
        $dom = document.createElement(vNode.type);
    }

    if (vNode.props) {
        Object.keys(vNode.props).forEach(key => {
            setProp($dom, key, vNode.props[key]);
        });
    }

    if (vNode.children && vNode.children.length) {
        vNode.children.forEach(childVdom => {
            const realChildDom = toRealDom(childVdom);
            $dom.appendChild(realChildDom);
        });
    }

    return $dom;
}

处理变化

Virtual DOM 之所以被创造出来，最根本的原因是性能提升，通过 Virtual DOM ，开发者可以减少许多不必要的 DOM 操作，以达到最优性能，那么下面我们来看看 Virtual DOM 算法是如何通过对比更新前的 Virtual DOM 树和更新后的 Virtual DOM 树来实现性能优化的。

注：本文是笔者的最简单实现，目前社区普遍通用的算法是snabbdom，如 Vue 则是借鉴该算法实现的 Virtual DOM ，有兴趣的读者可以查看这个库的源代码，基于本文的 Virtual DOM 的小示例，笔者最终也参考了该算法实现，本文demo传送门，由于篇幅有限，感兴趣的读者可以自行研究。

为了处理变化，首先声明一个updateDom函数，这个函数接受以下四个参数：

$parent，表示将被挂载的父节点；
oldVNode，旧的VNode对象；
newVNode，新的VNode对象；
index，在更新子节点时使用，表示当前更新第几个子节点，默认为0；

函数原型如下：

function updateDom($parent, oldVNode, newVNode, index = 0) {

}

新增与删除节点

首先我们来看新增一个节点的情况，对于原本没有该节点，需要添加新的一个节点到 DOM 树中，我们需要通过appendChild来实现：

转化为代码表述为：

// 没有旧的节点，添加新的节点
if (!oldVNode) {
    return $parent.appendChild(toRealDom(newVNode));
}

同理，对于删除一个旧节点的情况，我们通过removeChild来实现，在这里，我们应该从真实 DOM 中将旧的节点删掉，但问题是在这个函数中是直接取不到这一个节点的，我们需要知道这个节点在父节点中的位置，事实上，可以通过$parent.childNodes[index]来取到，这便是上面提到的为何需要传入index，它表示当前更新的节点在父节点中的索引：

转化为代码表述为：

const $currentDom = $parent.childNodes[index];

// 没有新的节点，删除旧的节点
if (!newVNode) {
    return $parent.removeChild($currentDom);
}

更新节点

Virtual DOM 的核心在于如何高效更新节点，下面我们来看看更新节点的情况。

首先，针对文本节点，我们可以简单处理，对于文本节点是否发生改变，只需要通过比较其新旧字符串是否相等即可，如果是相同的文本节点，是不需要我们更新 DOM 的，在updateDom函数中，直接return即可：

// 都是文本节点，都没有发生变化
if (typeof oldVNode === 'string' && typeof newVNode === 'string' && oldVNode === newVNode) {
    return;
}

接下来，考虑节点是否真的需要更新，如图所示，一个节点的类型从span换成了div，显而易见，这是一定需要我们去更新DOM的：

我们需要编写一个函数isNodeChanged来帮助我们判断旧节点和新节点是否真的一致，如果不一致，需要我们把节点进行替换：

function isNodeChanged(oldVNode, newVNode) {
    // 一个是textNode，一个是element，一定改变
    if (typeof oldVNode !== typeof newVNode) {
        return true;
    }

    // 都是textNode，比较文本是否改变
    if (typeof oldVNode === 'string' && typeof newVNode === 'string') {
        return oldVNode !== newVNode;
    }

    // 都是element节点，比较节点类型是否改变
    if (typeof oldVNode === 'object' && typeof newVNode === 'object') {
        return oldVNode.type !== newVNode.type;
    }
}

在updateDom中，发现节点类型发生变化，则将该节点直接替换，如下代码所示，通过调用replaceChild，将旧的 DOM 节点移除，并将新的 DOM 节点加入：

if (isNodeChanged(oldVNode, newVNode)) {
    return $parent.replaceChild(toRealDom(newVNode), $currentDom);
}

但这远远还没有结束，考虑下面这种情况：

<!-- old -->
<div class="item" data-item="old-item"></div>

<!-- new -->
<div id="item" data-item="new-item"></div>

对比上面的新旧两个节点，发现节点类型并没有发生改变，即VNode.type都是'div'，但是节点的属性却发生了改变，除了针对节点类型的变化更新 DOM 外，针对节点的属性的改变，也需要对应把 DOM 更新。

与上述方法类似，我们编写一个isPropsChanged函数，来判断新旧两个节点的属性是否有发生变化：

function isPropsChanged(oldProps, newProps) {
    // 类型都不一致，props肯定发生变化了
    if (typeof oldProps !== typeof newProps) {
        return true;
    }

    // props为对象
    if (typeof oldProps === 'object' && typeof newProps === 'object') {
        const oldKeys = Object.keys(oldProps);
        const newkeys = Object.keys(newProps);
        // props的个数都不一样，一定发生了变化
        if (oldKeys.length !== newkeys.length) {
            return true;
        }
        // props的个数相同的情况，遍历props，看是否有不一致的props
        for (let i = 0; i < oldKeys.length; i++) {
            const key = oldKeys[i]
            if (oldProps[key] !== newProps[key]) {
                return true;
            }
        }
        // 默认未改变
        return false;
    }

    return false;
}

因为当节点没有任何属性时，props为null，isPropsChanged首先判断新旧两个节点的props是否是同一类型，即是否存在旧节点的props为null，新节点有新的属性，或者反之：新节点的props为null，旧节点的属性被删除了。如果类型不一致，那么属性一定是被更新的。

接下来，考虑到节点在更新前后都有props的情况，我们需要判断更新前后的props是否一致，即两个对象是否全等，遍历即可。如果有不相等的属性，则认为props发生改变，需要处理props的变化。

现在，让我们回到我们的updateDom函数，看看是把Virtual DOM 节点props的更新应用到真实 DOM 上的。

// 虚拟DOM的type未改变，对比节点的props是否改变
const oldProps = oldVNode.props || {};
const newProps = newVNode.props || {};
if (isPropsChanged(oldProps, newProps)) {
    const oldPropsKeys = Object.keys(oldProps);
    const newPropsKeys = Object.keys(newProps);

    // 如果新节点没有属性，把旧的节点的属性清除掉
    if (newPropsKeys.length === 0) {
        oldPropsKeys.forEach(propKey => {
            removeProp($currentDom, propKey, oldProps[propKey]);
        });
    } else {
        // 拿到所有的props，以此遍历，增加/删除/修改对应属性
        const allPropsKeys = new Set([...oldPropsKeys, ... newPropsKeys]);
        allPropsKeys.forEach(propKey => {
            // 属性被去除了
            if (!newProps[propKey]) {
                return removeProp($currentDom, propKey, oldProps[propKey]);
            }
            // 属性改变了/增加了
            if (newProps[propKey] !== oldProps[propKey]) {
                return setProp($currentDom, propKey, newProps[propKey]);
            }
        });
    }
}

上面的代码也非常好理解，如果发现props改变了，那么对旧的props的每项去做遍历。把不存在的属性清除，再把新增加的属性加入到更新后的 DOM 树中：

首先，如果新的节点没有属性，遍历删除所有旧的节点的属性，在这里，我们通过调用removeProp删除。removeProp与setProp相对应，由于本文篇幅有限，笔者在这里就不做过多阐述；

function removeProp($target, name, value) {
    if (isCustomProp(name)) {
        return;
    } else if (name === 'className') { // fix react className
        return $target.removeAttribute('class');
    } else if (isEventProp(name)) {
        return $target.removeEventListener(extractEventName(name), value);
    } else if (typeof value === 'boolean') {
        $target.removeAttribute(name);
        $target[name] = false;
    } else {
        $target.removeAttribute(name);
    }
}

如果新节点有属性，那么拿到旧节点和新节点所有属性，遍历新旧节点的所有属性，如果属性在新节点中没有，那么说明该属性被删除了。如果新的节点与旧的节点属性不一致/或者是新增的属性，则调用setProp给真实 DOM 节点添加新的属性。

更新子节点

在最后，与toRealDom类似的是，在updateDom中，我们也应当处理所有子节点，对子节点进行递归调用updateDom，一个一个对比所有子节点的VNode是否有更新，一旦VNode有更新，则真实 DOM 也需要重新渲染：

// 根节点相同，但子节点不同，要递归对比子节点
if (
    (oldNode.children && oldNode.children.length) ||
    (newNode.children && newNode.children.length)
) {
    for (let i = 0; i < oldNode.children.length || i < newNode.children.length; i++) {
        updateDom($currentDom, oldNode.children[i], newNode.children[i], i);
    }
}

远远没有结束

以上是笔者实现的最简单的 Virtual DOM 代码，但这与社区我们所用到 Virtual DOM 算法是有天壤之别的，笔者在这里举个最简单的例子：

<!-- old -->
<ul>
    <li>1</li>
    <li>2</li>
    <li>3</li>
    <li>4</li>
    <li>5</li>
</ul>

<!-- new -->
<ul>
    <li>5</li>
    <li>1</li>
    <li>2</li>
    <li>3</li>
    <li>4</li>
</ul>

对于上述代码中实现的updateDom函数而言，更新前后的 DOM 结构如上所示，则会触发五个li节点全部重新渲染，这显然是一种性能的浪费。而snabbdom则通过移动节点的方式较好地解决了上述问题，由于本文篇幅有限，并且社区也有许多对该 Virtual DOM 算法的分析文章，笔者就不在本文做过多阐述了，有兴趣的读者可以到自行研究。笔者也基于本文实例，参考snabbdom算法实现了最终的版本，有兴趣的读者可以查看本文示例最终版