Skip to main content

由一篇文章引申出的关于原生 JavaScript 在 createTextNode 和 innerText 操作的性能差异的探究

前言#

昨天在浏览 RSS 推送的文章时，看到奇舞周刊推送了一篇 《我对 Svelte 的看法》 的文章，看到其中一段代码示例，使用原生 JavaScript 实现一个不使用 Virtual DOM 的 Counter：

const target = document.querySelector('#app');
// state
let count = 0;
// view
const div = document.createElement('div');
const countText = document.createTextNode(`${count}`);
div.appendChild(countText);
const button1 = document.createElement('button');
const button1Text = document.createTextNode(`+`);
button1.appendChild(button1Text);
const button2 = document.createElement('button');
const button2Text = document.createTextNode(`-`);
button2.appendChild(button2Text);
target.appendChild(div);
target.appendChild(button1);
target.appendChild(button2);
// event
button1.addEventListener('click', () => {
count += 1;
});
button2.addEventListener('click', () => {
count -= 1;
});

发现示例中给相关的 DOM 插入 Text 使用的是 document.createTextNode，由于我在写代码的过程中基本没有使用过这种方式来创建 TextNode 并作为子节点插入到相关的 DOM 中，于是对这个方法有了一丝好奇。

通常情况下，我都会选择使用 innerText 的方式将 Text 插入到相关的 DOM 中，这就产生了一个问题：

  • 在写代码的时候，到底是使用 document.createTextNode 创建 TextNode 并插入到相关的 DOM 中，还是直接使用 innerText 将 Text 插入更加高效？

思路#

为了获得这个问题的答案，第一个想到的办法是使用 Jest 分别跑两段测试代码，然后查看两者之间的时间差。

但是仔细一想，Jest 是跑在 Node 环境下的，不是浏览器环境，也就没有 DOM 对象，只能通过 JSDOM 来模拟，这样的话就是运行纯 JavaScript 了，少了 JavaScript 通过 Web IDL 修改 DOM 对象的过程，也就没办法测出这两种方式的差异。

关于这个知识点，可以看一下这份知乎回答：前端为什么操作 DOM 是最耗性能的呢？ - justjavac 的回答 - 知乎。

不过嘛，既然是测试，跑一跑也无妨，验证一下是不是真的如我想的那样无法测出非 DOM 操作和 DOM 操作之间的差异。

JSDOM#

document.title & document.xxx#

先上两段代码，来验证一下在 Node 环境下是不是真的无法测出非 DOM 操作和 DOM 操作之间的差异。

jsdom/dom.js
const {JSDOM} = require('jsdom');
const {window} = new JSDOM(``);
const {document} = window;
console.time();
for (let i = 0; i <= 1e4; i++) {
document.title = i;
}
console.timeEnd();
jsdom/non-dom.js
const {JSDOM} = require('jsdom');
const {window} = new JSDOM(``);
const {document} = window;
console.time();
for (let i = 0; i <= 1e4; i++) {
document.xxx = i;
}
console.timeEnd();

运行之后发现，事实并非我们想象的那样：

jsdom/dom.js
$ node jsdom/dom.js
default: 195.461ms
jsdom/non-dom.js
$ node jsdom/non-dom
default: 0.281ms

问题来了，为什么即使是在 Node 环境下也有如此大的差异？

Debug 了一轮之后发现，对 document.title 做修改的时候，会触发 setter：

dom.js

而对 document.xxx 做修改的时候仅仅只是一个赋值操作：

non-dom.js

这就出现区别了，document 对象是使用 Object.defineProperty 包装过部分属性的，其中 title 就重写了它的 getter/setter，因此在修改 document.title 的时候耗时明显增加。

不过这是在测试修改 document.title 和 document.xxx 的差异，跑题了！

现在回到测试 document.createTextNode 和 innerText 这两者的差异上。

createTextNode & innerText#

createTextNode.js
const {JSDOM} = require('jsdom');
const {window} = new JSDOM(`
<div id="root"></div>
`);
const {document} = window;
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e4; i++) {
const text = document.createTextNode(i);
root.append(text);
}
console.timeEnd();
innerText.js
const {JSDOM} = require('jsdom');
const {window} = new JSDOM(`
<div id="root"></div>
`);
const {document} = window;
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e4; i++) {
root.innerText += i;
}
console.timeEnd();

结果出人意料：

createTextNode.js
$ node jsdom/createTextNode
default: 103.349ms
innerText.js
$ node jsdom/innerText
default: 0.459ms

非常意外！于是我又 Debug 了一轮，发现 JSDOM 提供的 getElementById 的方法返回的 HTMLElement 并没有 innerText 这个属性。

与上面修改 document.xxx 的情况一样，修改 innerText 变成了一个简单的赋值操作。

Chrome#

Version 1#

既然在 Node 环境下没办法完成这个测试，于是我将试验场更换到了 Chrome，让我们看一下在 Chrome 中运行会有什么差异。

于是我创建了两个页面来进行测试：

createTextNode.html
<div id="root"></div>
<script>
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e4; i++) {
const text = document.createTextNode(i);
root.appendChild(text);
}
console.timeEnd();
</script>
innerText.html
<div id="root"></div>
<script>
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e4; i++) {
root.innerText += i;
}
console.timeEnd();
</script>

结果出人意料，差距实在太大了：

createTextNode.html
// default: 3.133056640625 ms
innerText.html
// default: 11603.7099609375 ms

这样看来，createTextNode 的性能显然比修改 innerText 好太多了。

不应该会有这么大的差距啊！是什么问题呢？

回到 JavaScript 代码，对比之后发现，修改 innerText 为了实现和 createTextNode 一样的行为，有一个 += 操作。

难道是这里耗时严重？

思考之后，决定重新设计这个实验，去掉 += 的操作，同时要保证最终的实现效果一致。

Version 2#

createTextNode.html
<div id="root"></div>
<script>
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e4; i++) {
const child = document.createElement('div');
const text = document.createTextNode(i);
child.appendChild(text);
root.appendChild(child);
}
console.timeEnd();
</script>
innerText.html
<div id="root"></div>
<script>
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e4; i++) {
const child = document.createElement('div');
child.innerText = i;
root.appendChild(child);
}
console.timeEnd();
</script>

实验改进之后，应该算严格控制了两个实验行为一致了，去掉了 += 操作，现在结果就非常接近了：

createTextNode.html
// default: 6.649169921875 ms
innerText.html
// default: 6.679931640625 ms

为了确保这个结果是准确的，我们将循环次数放大一个数量级，再测试一次。

循环次数放大一个数量级之后，结果是这样的：

createTextNode.html
// default: 54.6650390625 ms
innerText.html
// default: 54.66015625 ms

依然非常接近，基本没有差别。

是不是就能确定这两种不同的写法性能上没区别呢？

事实上改进后的实验，可能还存在问题，问题出在哪呢？

Version 3#

其实问题出在了循环体中的代码顺序上：

createTextNode.js
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e5; i++) {
const child = document.createElement('div');
const text = document.createTextNode(i);
child.appendChild(text);
root.appendChild(child);
}
console.timeEnd();
innerText.js
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e5; i++) {
const child = document.createElement('div');
child.innerText = i;
root.appendChild(child);
}
console.timeEnd();

为什么说问题出在了循环体中的代码顺序上呢？

因为在 child 被插入到 root 之前，它还是一个 JavaScript 对象，对 JavaScript 对象的属性做修改的速度是非常快的。

所以我们又修改了一下，把 child 插入 root 的代码提前，先插入到 root 中，再修改 Text。

createTextNode.js
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e5; i++) {
const child = document.createElement('div');
root.appendChild(child);
const text = document.createTextNode(i);
child.appendChild(text);
}
console.timeEnd();
innerText.js
const root = document.getElementById('root');
console.time();
for (let i = 0; i <= 1e5; i++) {
const child = document.createElement('div');
root.appendChild(child);
child.innerText = i;
}
console.timeEnd();

再来看结果：

createTextNode.html
// default: 57.946044921875 ms
innerText.html
// default: 56.62109375 ms

到这里我们应该能够确定，这两种方式插入 Text 在性能上没有区别了。

总结#

因为一次技术文章的阅读引出这么一些内容，然后测试了一下，也不确定测试方法对不对，如果有跟了解的大佬可以指点一下~

Edit this page
Last updated on by wjq990112