What’s The Deal With Vuejs Virtual DOM?
In this post we will show you What’s The Deal With Vuejs Virtual DOM, hear for What’s The Deal With Vuejs Virtual DOMs we will give you demo and example for implement.
Document Object Model – Vuejs Virtual DOM
DOM – It’s a way of representing a structured document via objects. It is cross-platform and language-independent convention for representing and interacting with data in HTML, XML, and others. Web browsers handle the DOM implementation details, so we can interact with it using JavaScript and CSS.
Virtual DOM vs Shadow DOMfor Vuejs Virtual DOM
Vue.js and React both use Virtual DOM so it is a known concept by many but often it is confused with Shadow Dom. For this reason, an article about which problem Shadow DOM tries to solve and how it differs from Virtual DOM was created by @develoger, made available here.
Virtual DOM is any kind of representation of a real DOM. Virtual DOM is about avoiding unnecessary changes to the DOM, which are expensive performance-wise, because changes to the DOM usually cause re-rendering of the page. It allows to collect several changes to be applied at once, so not every single change causes a re-render, but instead re-rendering only happens once after a set of changes was applied to the 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.
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.
// #myId could be anywhere in the document, which may have thousands of nodes!
document.getElementById('myId').appendChild(myNewNode);
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:
// An unordered list represented as Javascript
let domNode = {
tag: 'ul',
attributes: { id: 'myId' },
children: [
// where the LI's would go
]
};
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.
// This might be how we update the virtual DOM
domNode.children.push(‘
- Item 3
‘);
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:
// This function would call the DOM API and make changes // to the browser's DOM. It would do it in batches and with // more efficiency than it would with arbitrary updates. sync(originalDomNode, domNode);
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:
new Vue({
el: '#app',
data: {
message: 'hello world'
},
render(createElement) {
return createElement(
'div',
{ attrs: { id: 'myId' } },
this.message
);
}
});
Output:
<div id='app'> <div id='myId'>hello world</div> </div>
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 funtions allow JS extensions like JSX which may be desireable for architecting a component-based app.
Hope this code and post will helped you for implement What’s The Deal With Vuejs Virtual DOM. if you need any help or any feedback give it in comment section or you have good idea about this post you can give it comment section. Your comment will help us for help you more and improve onlincode. we will give you this type of more interesting post in featured also so, For more interesting post and code Keep reading our blogs onlincode.org