, or

) is a "node" in the tree. A Virtual DOM Node is a small object that represents one of these elements.

Here’s an example:

Virtual DOM Node:
{
  type: 'div',
  props: { id: 'container' },  // attributes like id, class, etc.
  children: [                 // children inside this element
    {
      type: 'p',              // a <p> tag (paragraph)
      props: {},
      children: ['Hello, world!']  // text inside the <p> tag
    }
  ]
}

This describes a

element with an id="container", which contains a

element with the text "Hello, world!".

Key Points:

• Each node has a type (e.g., div, p).
• It can have props (like id, class, etc.).
• It also has children which could be other elements or text.

---

Step 2: Rendering the Virtual DOM to the Real DOM

Now that we have a Virtual DOM, we need a way to turn it into real HTML on the page.

Let’s write a function called render that takes in a Virtual DOM node and converts it to an actual HTML element.

function render(vNode) {
  // 1. Create a real element based on the Virtual DOM type (e.g., div, p).
  const element = document.createElement(vNode.type);

  // 2. Apply any attributes (props) like id, class, etc.
  for (const [key, value] of Object.entries(vNode.props)) {
    element.setAttribute(key, value);
  }

  // 3. Process the children of this Virtual DOM node.
  vNode.children.forEach(child => {
    if (typeof child === 'string') {
      // If the child is just text, create a text node.
      element.appendChild(document.createTextNode(child));
    } else {
      // If the child is another Virtual DOM node, recursively render it.
      element.appendChild(render(child));
    }
  });

  return element;  // Return the real DOM element.
}

What Happens Here?

• We create an element (document.createElement(vNode.type)).
• We add any attributes (like id, class, etc.).
• We handle children (text or other elements) by either adding text or calling render again on each child element.

---

Step 3: Comparing (Diffing) the Old and New Virtual DOM

When something changes in our web app (like the text or an element’s style), we create a new Virtual DOM. But before we update the real DOM, we need to compare the old Virtual DOM and the new Virtual DOM to figure out what has changed. This is called "diffing".

Let’s create a function that compares the two Virtual DOMs:

Virtual DOM Node:
{
  type: 'div',
  props: { id: 'container' },  // attributes like id, class, etc.
  children: [                 // children inside this element
    {
      type: 'p',              // a <p> tag (paragraph)
      props: {},
      children: ['Hello, world!']  // text inside the <p> tag
    }
  ]
}

How the Diffing Works:

• Node Type Changes: If the type of element changes (like changing a
  to a

  ), we mark it for replacement.

• Text Changes: If the text inside changes, we update the text.
• Attributes & Children: We check if any attributes (props) or children of the element have changed.

---

Step 4: Patching the Real DOM

Once we know what has changed, we need to apply those changes to the real DOM. We call this process patching.

Here’s how the patching function might look:

function render(vNode) {
  // 1. Create a real element based on the Virtual DOM type (e.g., div, p).
  const element = document.createElement(vNode.type);

  // 2. Apply any attributes (props) like id, class, etc.
  for (const [key, value] of Object.entries(vNode.props)) {
    element.setAttribute(key, value);
  }

  // 3. Process the children of this Virtual DOM node.
  vNode.children.forEach(child => {
    if (typeof child === 'string') {
      // If the child is just text, create a text node.
      element.appendChild(document.createTextNode(child));
    } else {
      // If the child is another Virtual DOM node, recursively render it.
      element.appendChild(render(child));
    }
  });

  return element;  // Return the real DOM element.
}

Key Operations:

• REPLACE: Completely replace one element with another.
• TEXT: Update the text inside an element.
• UPDATE: Update attributes and children based on the changes.

---

Summary of the Virtual DOM Process:

1. Virtual DOM Tree: We create a tree-like structure that represents the elements and their hierarchy on a web page.
2. Render to Real DOM: This Virtual DOM is converted into real HTML elements and placed on the page.
3. Diffing Algorithm: When something changes, we compare the old Virtual DOM with the new one to find the differences.
4. Patch the Real DOM: Apply those changes to the real DOM in the most efficient way possible.

---

Final Thoughts

The Virtual DOM is a powerful tool that makes updating the user interface faster by reducing unnecessary changes to the real DOM. By implementing a Virtual DOM, we can optimize the way web apps update and render elements, leading to faster and smoother user experiences.

This is a basic implementation of the Virtual DOM concept, but you’ve now got the foundation to understand how frameworks like React make use of it!

The above is the detailed content of Designing a Virtual DOM from Scratch: A Step-by-Step Guide. For more information, please follow other related articles on the PHP Chinese website!