What is virtual DOM in React?

What is virtual DOM in React?

Welcome to another exciting post on codedamn! Today, we’ll delve into the mechanics of React, specifically focusing on the virtual DOM. By the end of this article, you’ll have a solid grasp of why the virtual DOM is integral to React’s performance and how it differentiates from the traditional DOM.


React is, without doubt, one of the most prominent JavaScript libraries for building user interfaces. Powering countless websites and applications, it’s heralded for its scalability, ease of use, and robust performance. As web applications have become increasingly complex, ensuring they run efficiently and effectively is paramount. For React, a lot of its performance prowess is attributed to the introduction of the “virtual DOM”.

What is the Document Object Model (DOM)?

The Document Object Model, more commonly referred to as the DOM, represents the structure of a webpage in a hierarchical, tree-like manner. Each element, attribute, and piece of text becomes a node in this tree. As developers, we interact with the DOM to manipulate and update web content dynamically.

Traditionally, every change made to the content, even minor ones, led to the entire DOM being rebuilt and the entire page re-rendered. This process was computationally expensive, leading to noticeable performance lag, especially when frequent updates were required.

The Concept of Virtual DOM

Enter the virtual DOM, React’s ingenious solution to this problem. In essence, the virtual DOM is a lightweight copy of the actual DOM. It serves as a middle-man, allowing React to determine the most efficient way to make changes to the real DOM.

While the real DOM is vast and feature-rich, the virtual DOM is streamlined, containing only the necessary parts. This comparison between the virtual and real DOM is fundamental to React’s efficiency. By updating this lightweight virtual DOM and subsequently making bulk updates to the actual DOM in a single go, React minimizes expensive DOM operations, leading to smoother, faster web applications.

How Virtual DOM Works

Initial Render

When you write a React component using JSX, this JSX isn’t directly understood by the browser. Instead, it’s transformed into React elements through a process called transpilation. These React elements then form the virtual DOM. Once the virtual DOM is set, React renders it to the actual DOM, making our components come alive on the web page.

Updates and Re-rendering

React components often rely on data which can change over time, like user inputs or new information fetched from an API. When such data changes, the associated React elements need updating. Instead of immediately changing the real DOM, React creates a new virtual DOM tree. Then, it compares this new virtual DOM with the current one in a process termed “Reconciliation”.

Reconciliation Process

This reconciliation is where React truly shines. Instead of making hasty updates, React uses a diffing algorithm to determine the most efficient way to apply changes.

Element Types

If React detects a difference in element types (e.g., a <div> becomes a <p>), it simply destroys the old tree and builds a new one. For the real DOM, this means removing the old elements and their children, then creating and adding the new ones. While this sounds costly, React’s diffing ensures that this happens only when absolutely necessary.

Component Types

When components update, React follows a similar process. If a component’s type changes, React again starts from scratch, leading to the destruction of the old component and its state. This is why, in React, preserving component state across re-renders is crucial and demands careful consideration.

Keys and List Reconciliation

In React, when rendering lists, it’s important to specify a unique key for each list item. The reason for this is tied to how React handles the process of list reconciliation, which is an optimization for updating lists.

Suppose you have a list and you make some updates, like removing an item or adding a new one. Without keys, React would find it challenging to determine which items have been added or removed. It might end up recreating the entire list, which can be very inefficient. By providing a unique key for each list item, you’re effectively giving React a hint about how to compare items from the old and new lists, enabling it to make more optimized decisions about what to update.

Performance considerations.
Not using keys, or using non-unique or unstable keys (like array indices), can lead to performance problems and even bugs in your app. With proper use of keys, React can avoid unnecessary re-renders, making your application faster and more responsive.

Benefits of Virtual DOM

Efficiency: The Virtual DOM approach reduces the number of direct manipulations on the actual DOM. Since direct DOM manipulations can be expensive (leading to reflows and repaints), this ensures more efficient updates.

Flexibility: Virtual DOM allows for specific optimizations, like lazy-rendering, which only renders portions of an application when it’s needed.

Improved User Experience: With fewer direct updates to the actual DOM, there’s less UI jitter. This translates to smoother interface interactions for the end user.

Abstraction: Virtual DOM abstracts away the direct operations on the real DOM, providing a consistent interface for developers while allowing the framework (React) to optimize rendering behind the scenes.

Common Misconceptions

  • “Virtual DOM is always faster than direct DOM manipulations.” While the Virtual DOM often improves performance, there are situations where direct DOM manipulations can be faster, especially for very simple updates.
  • “React always uses Virtual DOM for all updates.” React does rely on the Virtual DOM, but not all updates go through it. For instance, when using React’s dangerouslySetInnerHTML method, direct DOM updates occur.

Real-World Scenarios

Examples where Virtual DOM provides noticeable benefits: For large applications with frequent updates or large lists, the Virtual DOM can significantly optimize updates, improving performance.

Edge cases where Virtual DOM might not be as effective: For very simple applications or small DOM updates, the overhead of the Virtual DOM might not provide a noticeable benefit.

Balancing act: While React’s default behavior with the Virtual DOM is generally efficient, there are times when manual optimizations are needed. Developers should profile their apps and rely on React’s default behavior, only optimizing when necessary.

Virtual DOM Alternatives and Comparisons

  • Svelte’s compile-time optimizations: Unlike React’s runtime-based Virtual DOM, Svelte performs its optimizations at compile time, eliminating the need for a virtual representation during runtime. Official Svelte documentation
  • Vue’s reactive system and template-based optimization: Vue uses a reactive system and template-based optimization, making its approach somewhat different from React. However, it still employs a virtual DOM for efficient updates. Vue’s official guide
  • Incremental DOM: Instead of creating a full virtual representation like Virtual DOM, Incremental DOM updates the actual DOM directly but in smaller chunks, leading to a middle-ground between direct DOM manipulations and full virtual representations.

Optimizing Virtual DOM Performance

Use of Keys with Lists

As mentioned, using unique and stable keys when rendering lists in React can significantly optimize the rendering process by allowing React to quickly identify and update specific list items.

PureComponent and shouldComponentUpdate

React’s PureComponent and the shouldComponentUpdate lifecycle method can prevent unnecessary re-renders by shallowly comparing previous and current props and state. If they’re the same, the component doesn’t re-render.

useMemo and useCallback Hooks

These hooks can optimize the rendering process by memoizing values (useMemo) and functions (useCallback), ensuring that they remain consistent across renders unless dependencies change.


Virtual DOM, while not a silver bullet, provides a powerful abstraction that offers several benefits for building web applications, especially with React. By understanding its underlying principles, developers can ensure they’re making the most of what React has to offer.

References & Further Reading

  1. React Official Documentation – Virtual DOM and Internals
  2. Vue’s Comparison with Other Frameworks
  3. Svelte’s Rethinking Reactivity

Happy coding, and best of luck on your journey with codedamn!

Sharing is caring

Did you like what Mehul Mohan wrote? Thank them for their work by sharing it on social media.


No comments so far