What’s The Deal With Vue’s Virtual DOM?
Many Javascript frameworks like Vue, React and Ember implement a “virtual DOM”.
While it sounds like something from a sci-fi, its main purpose is to increase the speed and efficiency of DOM updates. It offers some additional benefits as well.
Note: this article was originally posted here on the Vue.js Developers blog on 2017/02/20
Reminding ourselves what the DOM actually is
We tend think of the DOM as the HTML document it represents. But actually the DOM is a tree-like data structure that comes into existence once an HTML document has been parsed by the browser.
The browser paints the DOM to the screen and will repaint it in response to user actions (e.g. mouse clicks) and updates via its API from your Javascript scripts e.g. document.createElement.
It’s expensive to update the DOM
When we use Javascript to make a change to our page, the browser has to do some work to find the required DOM nodes and make the change e.g.
In modern apps there can be thousands of nodes in the DOM, and so updates can be computationally expensive. It’s inevitable that small, frequent updates will slow the page down.
What is a virtual DOM?
The DOM can be represented as a data structure in Javascript, too. Here is pseudo-code of how a DOM node could be represented:
If we call that a “virtual” DOM node, then the complete structure of DOM nodes would make up our virtual DOM.
But why do this?
It’s not very expensive to update virtual nodes.
If we use a virtual DOM, rather than our code directly calling the DOM API with methods like .getElementById to make updates, the code will make changes just to the JS object, which is cheap.
Then, when it’s time to get the real DOM in sync with the changes we’ve made, an efficient updating function is used:
In any one cycle there may be many nodes to update, so batching API calls in this way could reduce a lot of inefficiency.
More than performance
Having a virtual DOM it not just a performance enhancement, it means additional functionality will be possible.
For example, in Vue.js, you can bypass the need for an HTML template or a template property by using a render() method, which returns virtual nodes:
Output:
Why do this? There are several possible advantages:
- You get the programmatic power of Javascript. You could create factory-style functions to build your virtual nodes using Javascript’s array methods etc, something that would be more difficult using template syntax.
- You can make your code universal. Since your Vue instance does not really on an HTML file it is also renderable by a server for server-side rendering.
- JSX. Render functions allow JS extensions like JSX which may be desirable for architecting a component-based app.
