DOM vs Virtual DOM vs Shadow DOM
TL;DR
- "real" DOM: represents what you see on your screen; One page have one single DOM; any change will make a rerending of the whole object.
- Virtual DOM and Shadow DOM are trying to resolve the performance issue in different ways:
- Virtual DOM is creating a copy of the whole DOM object and keep it in memory to track changes
- Shadow DOM creates small pieces of the DOM object which has their own, isolated scope for the element they represent.
- Examples: React.js uses Virtual DOM; Lit (based on Web Components) uses Shadow DOM; Solid.js uses real DOM.
DOM
- the browser parses the HTML to a tree-like structure; each tree node is an object.
- JavaScript can access and do changes in the DOM.
window.document. - The whole page is a single big DOM tree. Performance issue: Every change will make a re-rendering of the whole object.
Virtual DOM
- Defined and managed by React, to mirror the real DOM (It saves a copy of DOM in memory)
- faster to chagne; changes to the states will first be applied to Virtual DOM; only if it requires UI Changes,
ReactDOMwill then update the real DOM.
Shadow DOM
- comes in small pieces; it does not represent the whole DOM, only sub-trees.
- Shadow DOM creates a scoped tree that connects to an element; the element is called shadow host.
- everything added to Shadow DOM is local (including styles).
- Benefits:
- it isolates the DOM, the component is a separate element that does not appear in the DOM.
- it simplifies styling: styles created in a single Shadow DOM element is isolated.
- An application using Shadow DOM is not one single big tree, but built on components.
Recommended Reading
SponsoredVersus
- 32-bit vs 64-bit
- AES vs RSA
- Agent vs Agentless
- Annotations vs Decorators
- Terraform vs Ansible
- BASH vs ZSH
- BigQuery vs Bigtable
- Block Storage vs File Storage vs Object Storage
- Canvas vs SVG
- cgroupfs vs systemd
- Constructor vs Init() vs Factory
- Container Image vs Helm Chart vs OCI Bundle
- Containers vs Virtual Machines (VMs)
- C vs C++
- Java vs C++
- Rust vs C++
- crictl vs ctr
- Dagger vs Guice
- DMA vs RDMA
- DOM vs Virtual DOM vs Shadow DOM
- DQL vs DDL vs DCL vs DML
- eBPF vs Sidecar
- Flux vs Redux
- Full Disk Encryption vs Partition Encryption
- Gatekeeper vs OPA
- Google vs Open Source
- Why MCP uses JSON-RPC 2.0 instead of grpc
- gRPC vs OpenAPI
- gtag.js vs Google Tag Manager (GTM)
- Versus
- Kotlin vs Java
- Jetty vs Netty
- .js vs .jsx vs .ts vs .tsx
- Kata Containers vs KubeVirt
- Linux Namespace vs Kubernetes Namespace
- Linux vs BSD
- LLVM vs JVM
- Data Mining vs Machine Learning vs Artificial Intelligence vs Data Science
- Managed Kubernetes vs Self-managed Kubernetes
- Management Plane vs Control Plane vs Data Plane
- Microcontroller vs Microprocessor vs Computer
- MMU vs IOMMU
- Single-tenant vs Multi-tenant vs Multi-single-tenant
- Multithreading vs Multiprocessing vs Distributed Systems
- Node.js vs Erlang
- OCI Image vs Docker Image
- OCI vs CRI
- OpenSSH vs OpenSSL
- Pass-by-value vs Pass-by-reference
- Podman vs nerdctl
- POSIX vs SUS vs LSB
- Private Key vs Public Key vs Certificate
- Proto Edition 2024 vs Proto Edition 2023
- Proto2 vs Proto3 vs Proto Editions
- Message Queue vs PubSub
- React vs Flutter vs Angular
- REST vs SOAP
- RSA vs ECDSA
- select vs. poll vs. epoll
- SLI vs SLO vs SLA
- Spanner vs Bigtable
- Static Site Generation vs Server-side Rendering vs Client-side Rendering
- Stack based VM vs Register based VM
- Stateless vs Stateful
- Strong Consistency vs Eventual Consistency
- stubs vs mocks vs fakes
- Subroutines vs Coroutines vs Generators
- Software Engineer vs Site Reliability Engineer
- Symlinks vs Hard Links
- JAX vs Tensorflow
- Tensorflow vs PyTorch
- Terminal vs Shell
- Throttling vs Load Shedding
- Unix Domain Sockets vs Network Sockets
- Unix Domain Sockets vs Shared Memory
- URI vs URN vs URL vs URC
- Valkey vs Redis vs Memcached
- Vi vs Vim vs gVim vs Neovim
- WAL vs rollback journal

