What is the DOM?
Tags: webdev, beginners, dom, html
Published: 2022-05-16 21:46:14

---
title: What is the DOM?
published: true
description: An explanation of what the DOM (Document Object Model) is
tags: #webdev #beginners #dom #html
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/sog5ydgds3pazrzya9j2.jpg
---


The DOM stands for **Document Object Model**, which is an interface that represents the contents of a HTML or XML document.

This interface is a collection of objects, actions, attributes and relationships, which is collectively is known as an Object Model. 

The DOM provides developers with a language-independent application programming interface to access and manipulate the document.

Documents as a result can be *as dynamic as web app or as static as a read-only page* 

---

*For the rest of this article, I will be discussing the DOM in relation to HTML documents (web pages)  which are accessed in web browsers, such as Chrome, Safari, Edge or Firefox.*

---


&nbsp; 
## How is the DOM created?

**The browser first needs to process the document, in order to use it.**

Before a web browser can display or use a HTML document, it needs to create the DOM. It does this by downloading and processing the document, creating the resulting object model in its memory.

Various processes need to take place, in order to create the DOM:

**Bytes** > **Conversion** > **Tokenizing** > **Lexing** > **DOM construction**

- **Bytes**:- the browser reads the document in a stream of bytes, via packets sent across the internet or retrieved from local disk. 
- **Conversion**:- these bytes are then converted into characters based upon the encoding specified in the document (usually `UTF-8`). 
- **Tokenizing**:- the characters are then pattern matched into tokens as defined by the HTML specification, such as `<body>`,`<div>` 
- **Lexing**:- the tokens are then converted into "objects", which define their properties and rules. 
- **DOM construction**:- finally the relationships of these objects are built into a tree-like structure (*a parse tree*) as defined by the HTML document. 

	- The entire document is represented by a `document` node.
	- The `<html>` element is the root element , which represents the top-most part of the HTML document.
	- All other nodes are descendants of the root element, within the DOM. 

  For example: the `head` and `body` element nodes are descendants of the root `html` node.
![Diagram of DOM hierarchy:- document, html, head, body tags](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rt9ngba77xxywly4qrfp.png)

  More than one child node creates a sibling relationship.
 e.g. `li`'s are siblings within the `ul` tag.
  ![Diagram of DOM siblings:- li elements within ul tag](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5c0hw9usrs72e5r6m3hu.png)

Every time the browser processes HTML, this DOM creation process runs. 


#### Browsers are tolerant of HTML errors
During the DOM creation phase, the browser will address various issues or errors it encounters with the source HTML.  This error handling results in a resilient foundation for our web page/app content. 


&nbsp; 
## Features of the DOM

The document object model covers:
- **Interfaces and objects** used to manipulate the document
- The **meaning** of these interfaces and objects, including attributes and behaviour
- The **relationships** and **collaborations** among the interfaces and objects
&nbsp; 

### Logical structure 
The DOM closely represents the document's structure via nodes and links, whereby:
- HTML elements, attributes, text etc are represented by **nodes** (*a basic unit in a data structure*)
     - (Each node contains objects)
- **Links** or pointers are used between nodes, which represent the nodes hierarchical relationships to each other

####  Tree structure
The logical structure is generally thought of as a tree-like structure, so you may encounter terms such as '*document tree*' and '*DOM tree*'  when describing the document's structure or hierarchy.  This tree-like structure, is not a DOM specification or implementation requirement, however, it is a generally understood mental model to have for HTML documents. 

###  Properties and methods
The object model provides properties and methods, which allow developers to find, access and interact with the document's contents

- **Properties** are <u>values</u> of objects (*typically HTML elements*) which you can return or change, such as `classList`, `innerHTML`, `innerText`  etc.
  
- **Methods** are <u>actions</u> related to DOM objects, such as `querySelector()`, `createElement()`, `addEventListener()` etc

Properties and methods vary depending upon the node type in the DOM.


### Representative types/objects
The object model can represent the HTML document in various ways.  How a document part is represented, will  determine how it can be interacted with (i.e. what properties and methods it has).

#### Node type
Every node in the DOM has a node type.
There are 12 node types in total but some node types have been deprecated. The integer (number) value represents the type of the node.

**Notable** node types include:

-  **ELEMENT_NODE (1)**
	- Which represent HTML tags such as `div`,`body`,`p`
-  **TEXT_NODE (3)**
	- The text/string value between HTML tags
-  **COMMENT_NODE (8)**
	- The comment value in the HTML
-  **DOCUMENT_NODE (9)**
	- This represents the entire document in the tree structure

**Attribute values**
Values such as `id`,`class`  `href` are technically not part of the DOM tree.
> since they are not actually child nodes of the element they describe, the DOM does not consider them part of the document tree.
>...
The DOM takes the view that attributes are properties of elements rather than having a separate identity from the elements they are associated with

Source: [Document Object Model (DOM) Level 3 Core Specification - Interface  _Attr](https://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-637646024)

Attribute objects inherit the node interface and have a node type:   **ATTRIBUTE_NODE (2)**

&nbsp; 
#### Collections
Depending upon DOM selection method used and the node(s) selected, the returned value could be a collection of elements/nodes rather than a single element or node.

##### Nodelists
Nodelists are collections of nodes, which are array-like in nature. Nodelists may be looped over using `forEach` when interacting with the DOM. 
Nodelists can contain text and attributes nodes. 

##### HTMLCollection
HTMLCollections are collections of elements (tags) unlike Nodelists, which can contain all node types. Like NodeLists, HTMLcollections are array-like.

HTMLCollection is a historical interface returned by the older DOM selection methods
`getElementsByTagName()`
`getElementsByClassName()`

Collection values can be either live or static:
- Live values update when the DOM updates
- Static values are obtained only when DOM selection is executed, they are unaffected by future updates to the DOM

**Note**
Both `NodeLists` and `HTMLcollections` can be converted to JavaScript arrays,  granting developers greater flexibility in data manipulation (with methods unavailable in these array-like data structures). 

&nbsp; 
## DOM interface / Web APIs
Although the DOM is cross-platform and language independent, it's typically manipulated with JavaScript in the browser. 

When working with the DOM in JavaScript, expressions are imperatively structured. 
This means we are telling the browser **exactly** what to do, such as:  *select a DOM node and perform an action on that selection.*


This can be done directly on the DOM selection:
e.g. 
```js
document.getElementById("heading").style.color = "blue";
```

or by using JavaScript variables to more effectively structure the code.
```js
const pageTitle = document.getElementById("heading");
pageTitle.style.color = "blue";
pageTitle.style.textTransform  = "Uppercase";
```

The DOM API provides various properties and methods to manipulate the document, which can be grouped by type/function, such as:
 
 - **Selection**
 - **Traversal** (*navigating between nodes*)
 - **Creating or updating content** 
 - **Deleting or  removing content** 
 - **Styling content** 
 - **Node/collection methods** 
 - **Events**

---
###  Declarative DOM manipulation
For many developers, direct DOM manipulation is too verbose (e.g. overly long method names) and too expensive  for modern web app implementations. 

Developers found their implementations would grow complexity (numerous DOM event listeners) with performance downsides of frequent DOM updates.

Developers as a result, will now often use a JavaScript framework or library instead, which takes care of this complexity for them.  These tools provide the developer with a declarative interface, where they can tell the browser/program logic "*what to do*" instead of "*how to do it*". 

Examples include: *React, Vue, Svelte etc*

In these cases, the framework/library does the DOM manipulation for the developer, usually with an intermediary step (such as a Virtual DOM or compilation).

---

&nbsp; 
## What ISN'T the DOM?
When working with the DOM, it's worth knowing what isn't the DOM, particularly when using browser dev tools. 

### The DOM is not your HTML markup

The DOM is not your source  `.html` file,
it is not viewable when you `View page source`.

Although the DOM is a representation of the document, it is not an exact duplication in the browser. The browser will fix various issues with the underlying mark up (HTML). 

Such as:
- Inserting omitted `tbody` tags into `table` structures
- closing unclosed tags 
- moving tags incorrectly nested in other elements



### The DOM is not static

Since the DOM is not your markup, it can be continually amended and updated with JavaScript, once the JavaScript has been loaded and run in the browser (*the client*) .   

DOM manipulation can happen as part of the script's program design,  it may also happen as part of scripted responses to user input or events, which can occur at any time. 


#### Client-side JavaScript can be executed from various sources:

 - **Within the HTML document** (via `<script>` tags) 
 - **Linked externally** via markup.
 - **Dynamically loaded** with JavaScript 
 - **Browser extension**
    
    **Note**: *browser extensions often dynamically append elements to the DOM. Bare this in mind, when troubleshooting web pages/applications.* 

### The DOM is not CSS content

When inspecting elements in browser devtools, you may also see CSS pseudo-elements (`::before`, `::after`)  near DOM elements. CSS pseudo-elements aren't part of the DOM, you can't manipulate them using DOM APIs and JavaScript. 

### The DOM is not JavaScript
Although you may write DOM APIs in JavaScript, DOM APIs aren't JavaScript nor are its objects the same as JavaScript objects. 

`querySelector` != `JavaScript`

The DOM is after all, an interface for JavaScript to interact with the source document. 

&nbsp; 
## Related models/concepts

### BOM
BOM stands for Browser Object Model and is a related object model used for interacting with documents inside web browsers. 

The BOM is an unofficial standard but generally consists of the following objects:
`Navigator`
`Window`
`Location` 
`History`
`Frame`

The `document` object is child object of the `window` object, which is a global object for the browser. 

The BOM like the DOM, has it's own properties and methods.  For example, the `DOMContentLoaded` window event, fires when the initial HTML has been loaded and parsed, regardless of stylesheet, image and subframe loading state.

### CSSOM and Render Tree
Beside the DOM, the browser also creates an accompanying CSS Object Model, (the CSSOM) taking into account all the styles applied to the document, from various sources (_external, embedded, inline, user-agent, etc_).

The browser then combines the DOM and CSSOM in a render tree, using only the nodes needed to render the web page. 

The browser will use the render tree to paint/render the document to the device's screen. 

The DOM and CSSOM, are independent models and form the critical rendering path.

### Accessibility tree
Browsers will create the accessibility tree *based upon the DOM*.  This tree exposes the accessible objects for HTML elements to assistive technologies and its users.

For accessible web pages, it is important to author HTML in a semantic/meaningful way, wherever possible adhering to web standards.