Document Object Model
The Document Object Model is a platform-independent programming interface that represents a document as a structured tree of nodes and provides ways to access and modify its content and structure.
Build a Frontend Web Framework (From Scratch)
The standardized tree-like representation of an HTML or XML document that scripts and browser APIs can inspect and modify.
- How it is used
- Serves as the browser-managed view that application code or a framework changes when state changes.
- How deep it goes
- Defines the DOM as a tree and works through direct element operations, while deferring browser rendering internals to an external resource.
- Examples
- Uses a to-do application to create, replace, and remove nodes, and compares virtual trees to identify changes.
- What you can do after
- Build it from scratch: render and update a small to-do interface with browser DOM operations and event listeners.
Read how Build a Frontend Web Framework (From Scratch) explains Document Object Model →
Vanilla Web
The browser programming interface for querying and manipulating a document's DOM representation.
- How it is used
- Updates browser interfaces directly by querying and manipulating the document’s node tree.
- How deep it goes
- Explains node relationships, lookup, mutation, rendering timing, and practical API choices, without descending into rendering-engine internals.
- Examples
- Creates a heading with `createElement` and renders shopping-cart items by cloning and filling a template.
- What you can do after
- Build it from scratch with native DOM APIs to query, create, move, and update interface nodes.
D3.js in Action, Third Edition
The Document Object Model is a programming interface that represents a web document as a structured tree of objects and elements.
- How it is used
- Supports web-page rendering and D3 visualization by representing, selecting, creating, and modifying document elements.
- How deep it goes
- Explains tree structure, element state, SVG painting order, and core D3 operations, then defers framework integration trade-offs to strategies.
- Examples
- Uses a nested HTML file, SVG shapes, CSS-style selectors, and framework-built scatterplots to illustrate document structure and control.
- What you can do after
- Apply D3 selections, append elements, and modify attributes and styles to build HTML or SVG visualizations.
Read how D3.js in Action, Third Edition explains Document Object Model →
Learn Go with Pocket-Sized Projects
The DOM, or Document Object Model, is a programming interface representing an HTML or XML document as an object tree that scripts can inspect and modify.
- How it is used
- Uses the DOM to build an interactive HTML multiplication quiz with Go running through WebAssembly.
- How deep it goes
- Explains element lookup, property reads and writes, callbacks, validation, and input resetting, while deferring broader browser internals.
- Examples
- Demonstrates operand spans, numeric form input, alert feedback, answer validation, and generated multiplication exercises.
- What you can do after
- Build interactive browser pages by reading and changing HTML elements from Go through WebAssembly.
Read how Learn Go with Pocket-Sized Projects explains Document Object Model →
Web Components in Action
The standardized object representation of an HTML or XML document that scripts and browsers can inspect and manipulate.
- How it is used
- Uses the DOM to distinguish creating a custom element from connecting it to the page.
- How deep it goes
- Explains creation, attachment, detached containers, and constructor limitations, but stops short of general DOM traversal.
- Examples
- Uses browser-console commands, custom-element listings, detached containers, and body append operations.
- What you can do after
- Apply via browser JavaScript by creating elements, inserting them, and predicting when connectedCallback runs.
Read how Web Components in Action explains Document Object Model →
Modern Angular
The DOM is the browser's in-memory tree representation of a document and its elements.
- How it is used
- Guides Angular’s translation of declarative templates into browser-rendering commands while exposing SSR constraints around direct DOM access.
- How deep it goes
- Traces JIT and AOT compilation plus render-phase DOM scheduling, but stops short of explaining generated JavaScript commands.
- Examples
- Uses routed standalone templates, an image and links, plus a scroll-to-top component that reads window afterNextRender.
- What you can do after
- Diagnose SSR failures from browser-only DOM APIs and schedule DOM reads or writes with Angular render callbacks.
HTML5 in Action
The Document Object Model is a programming interface that represents a document as a structured tree of objects.
- How it is used
- Connects JavaScript to document elements so applications can add dynamic interaction and use element-specific APIs.
- How deep it goes
- Surveys the DOM’s role and HTML5 APIs, leaving detailed treatment of those APIs to later topics.
- Examples
- Uses dynamic element interaction, inline server updates, and microdata retrieval or modification as application examples.
- What you can do after
- Understand how DOM APIs support dynamic interaction and connect to HTML5 application features.
Grokking Web Application Security
The Document Object Model is a programming interface representing an HTML or XML document as a tree of objects that scripts can inspect and modify.
- How it is used
- Supports browser rendering and client-side page updates by representing web-page structure for layout, styling, and JavaScript changes.
- How deep it goes
- Explains the DOM’s rendering role, script timing, and update behavior without detailing DOM APIs or object internals.
- Examples
- Uses deferred, inline, and external scripts plus scrolling, clicks, and text entry as DOM interaction examples.
- What you can do after
- Evaluate/understand when scripts can act on a page and which system-level actions browser sandboxing blocks.
Read how Grokking Web Application Security explains Document Object Model →
.NET in Action, Second Edition
A DOM is an in-memory tree representation of structured document data whose nodes can be inspected and modified.
- How it is used
- Uses an in-memory JSON representation to inspect and filter complete documents from file or network streams.
- How deep it goes
- Explains whole-document parsing, traversal, property access, and disposal, but defers alternative parsing use cases and serializer details.
- Examples
- Demonstrates filtering a jokes array by category while reading from a stream and writing to a file or console.
- What you can do after
- Apply it via JsonDocument to parse, traverse, inspect, filter, and dispose of complete JSON documents.
Read how .NET in Action, Second Edition explains Document Object Model →
Web Component Development with Modern Libraries and Tooling
The Document Object Model is a tree-structured representation of an HTML or XML document and its nodes.
- How it is used
- Explains how JavaScript accesses and modifies document objects to update browser displays and support reusable web components.
- How deep it goes
- Defines the DOM as a tree of Node objects and identifies elements, attributes, text, and comments without detailing traversal or mutation APIs.
- Examples
- Uses img syntax and a hello-world custom element to contrast optional and required closing tags.
- What you can do after
- Evaluate document structure by recognizing its tree of nodes and the markup rules for custom elements.
Pro Angular 16
The DOM API is the browser programming interface for creating, reading, and modifying nodes in a document object model.
- How it is used
- Explains how browsers represent HTML and how Angular-driven changes reach displayed client-side content.
- How deep it goes
- Defines the live object model and property binding, but stops short of detailed DOM API interrogation or node-creation procedures.
- Examples
- Uses document structure, an input value property, an Angular property-binding listing, and rendered-content tests.
- What you can do after
- Evaluate how HTML elements become JavaScript objects and apply Angular property binding to update rendered element state.
Secrets of the JavaScript Ninja, Third Edition
The DOM is the programming interface representing a web document as a tree of objects that scripts can inspect and modify.
- How it is used
- Represents page content so JavaScript can read and modify it to add interactivity.
- How deep it goes
- Explains parsing, tree relationships, and script execution timing without detailing DOM APIs.
- Examples
- Uses malformed markup with a paragraph in head to show browser correction into body.
- What you can do after
- Understand how browsers build a DOM from HTML and how scripts interact with it.
Read how Secrets of the JavaScript Ninja, Third Edition explains Document Object Model →
Also covered in
- Architecting AccessibilityIn early access (MEAP)
- Building User-Friendly DSLs
- CSS in Depth, Second Edition
- Secrets of the JavaScript Ninja, Second Edition
- Essential TypeScript 5, Third Edition
- React Quickly, Second Edition
- Digital Twins in Action
- Rust Servers, Services, and Apps
- Grokking Simplicity
What to know first
- HTMLHTML is the standard markup language for structuring content and elements in documents on the web.
- JavaScriptJavaScript is a high-level, dynamically typed programming language standardized as ECMAScript and used for web and general-purpose programming.
- CSSCSS (Cascading Style Sheets) is a stylesheet language for specifying the presentation and layout of structured documents.
- handlerA handler is a software routine or component invoked to process an event, request, message, or other input.
Related concepts
- virtual DOMcontrasts with · A virtual DOM is an in-memory user-interface tree that frameworks compare or process to determine updates to the rendered DOM.
- browserproduced by · A web browser is software that retrieves, interprets, and renders web resources, executes supported web content, and enables interaction with web applications.
- reconciliationused by · Reconciliation is the process of comparing related states, records, or outputs to identify differences and, when needed, resolve them or bring them into agreement.
- screen readerused by · A screen reader is assistive software that presents digital content and interface information through synthesized speech or refreshable braille.
- script elementused by · A script element is an HTML element that embeds script content or references an external script resource for processing by a browser.
- JavaScriptused by · JavaScript is a high-level, dynamically typed programming language standardized as ECMAScript and used for web and general-purpose programming.
Questions about Document Object Model
What is Document Object Model?
The Document Object Model is a platform-independent programming interface that represents a document as a structured tree of nodes and provides ways to access and modify its content and structure.
Which Manning books explain Document Object Model?
Build a Frontend Web Framework (From Scratch), Vanilla Web, D3.js in Action, Third Edition, Learn Go with Pocket-Sized Projects, Web Components in Action, Modern Angular, HTML5 in Action, Grokking Web Application Security and 4 more.
What should I know before learning Document Object Model?
Manning books that teach Document Object Model usually introduce HTML, JavaScript, CSS and handler first.
What is the difference between Document Object Model and virtual DOM?
The Document Object Model is a platform-independent programming interface that represents a document as a structured tree of nodes and provides ways to access and modify its content and structure. A virtual DOM is an in-memory user-interface tree that frameworks compare or process to determine updates to the rendered DOM.
What is Document Object Model also called?
Document Object Model is also called DOM.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.











