liveBook · Manning

Document Object Model

Also called 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.

How 12 Manning books explain it

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.

Read how Vanilla Web explains Document Object Model →

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.

Read how Modern Angular explains Document Object Model →

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.

Read how HTML5 in Action explains Document Object Model →

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.

Read how Web Component Development with Modern Libraries and Tooling explains Document Object Model →

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.

Read how Pro Angular 16 explains Document Object Model →

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

What to know first

Related concepts

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.