The Document Object Model (DOM) is the model that describes how all elements in an HTML page,
like input fields, images, paragraphs etc., are related to the topmost structure: the
By calling the element by its proper DOM name, we can influence it.
This page treats some DOM history and then describes the Level 0 DOM.
First of all a little introduction to the Document Object Model, followed by a bit of history. Then we'll take a look at accessing elements through the Level 0 DOM and how to use the Level 0 DOM.
to access bits of HTML and change its properties. For instance, when you write a
mouseover script you want to go to a certain image on
the page and change its
src property. When you do this, the browser reacts by changing the image
on the screen.
The function of the Document Object Model is to provide this kind of access to HTML elements on your page. Exactly what elements you can access in which way and exactly what you can change depends on the browser. Each higher browser version gives you more freedom to reach any element you like and change anything you like.
There are three DOM levels:
Now let's take a look at the origins and development of the Document Object Model.
For reasons of backward compatibility the more advanced browsers, even those who support the Level 1 DOM, still also support the old, faithful Level 0 DOM. Not supporting it would mean that the most common scripts suddenly wouldn't work any more. So even though the Level 0 DOM doesn't entirely fit into the new DOM concepts, browsers will continue to support it.
Therefore the Level 0 DOM is really unified: all browsers that support parts of it support these parts in the same way. With the later DOMs this situation changed.
When the Version 4 browsers were released, the hype
of the day was DHTML so both browsers had to support it. DHTML needs
access to layers, separate parts of a page that can be moved across the page. Not surprisingly in
view of their increasing competition, Netscape and Microsoft chose to create their own, proprietary
DOMs to provide access to layers and to change their properties (their position on the page, for instance).
Netscape created the layer model and the DOM
document.layers, while Microsoft used
Fortunately, nowadays these intermediate DOMs are not important any more. You can safely forget them.
Meanwhile W3C had developed the Level 1 DOM specification. The Document Object Model W3C proposed was at first written for XML documents, but since HTML is after all a sort of XML, it could serve for browsers too.
Besides, the Level 1 DOM is a real advance. For the first time, a DOM was not only supposed to give an exact model for the entire HTML (or XML) document, it is also possible to change the document on the fly, take out a paragraph and change the layout of a table, for instance.
Since both Netscape and Microsoft had participated in the specification of the new DOM, since both browser vendors wanted to support XML in their version 5 browser and since public pressure groups like the Web Standards Project exhorted them to behave sensibly just this once, both decided to implement the Level 1 DOM.
Of course, this doesn't mean that Mozilla and Explorer 5 are the same. Again for reasons of
backward compatibility Microsoft decided to continue support of
that Explorer 5 now supports two DOMs .
On the other hand, the core of Mozilla is being built by the open source Mozilla Project and the leaders of this project have decided to completely ditch the old
DOM of Netscape 4 and have Mozilla support only the Level 1 DOM.
See the Level 1 DOM page for more information.
Each DOM gives access to HTML elements in the document. It requires you, the web programmer, to
invoke each HTML element by its correct name. If you have done so, you can influence the element
(read out bits of information or change the content or layout of the HTML element). For instance, if you want to
influence the image with
name="first" you have to invoke it by its proper name
and you are granted access. The Level 0 DOM supports the following nodeLists:
document.images, which grants access to all images on the page.
document.forms, which grants access to all forms on the page.
document.forms.elements, which grants access to all form fields in one form, whatever their tag name. This nodeList is unique to the Level 0 DOM; the W3C DOM does not have a similar construct.
document.links, which grants access to all links (
<a href>) on the page.
document.anchors, which grants access to all anchors (
<a name>) on the page.
When the browser concludes that an HTML document has been completely loaded, it starts
making arrays for you. It creates the array
document.images and puts all images on the
page in it, it creates the array
document.forms and puts all forms on the page in it etc.
This means that you now have access to all forms and images, you just have to go through the array in search of the exact image or form that you want to influence. This can be done in two ways: by name or by number.
Suppose you have this HTML document:
------------------------------------------- | document | | -------- ------------------- | | |img | | second image | | | -------- | | | | ------------------- | | ------------------------------------- | | | form | | | | --------------------- | | | | | address | | | | | --------------------- | | | ------------------------------------- | -------------------------------------------
The first image has
name="thefirst", the second has
name="thesecond". Then the
first image can be accessed by either of these two calls:
The second one can be accessed by either of these calls:
The first call is by name, simply fill in the name
 and you're ready.
The second call is by number. Each image gets a number in the
document.images array, in
order of appearance in the source code. So the first image on a page is
the second one is
The same goes for forms. Suppose the form on the page has
name="contactform", then you
can reach it by these two calls:
But in the case of forms, usually you don't want to access just the form, but a specific form field.
No problem, for each form the browser automatically creates the array
that contains all elements in the form.
The form above holds as first element an
<input name="address">. You can
access it by these four calls:
document.forms['contactform'].elements['address'] document.forms['contactform'].elements document.forms.elements['address'] document.forms.elements
These four calls are completely interchangeable, it's allowed to first use one, then another. It depends on your script exactly which method of access you use.
Once you have correctly accessed a form field or an image through the Level 0 DOM, you'll have to do
what you want to do. Images are usually accessed to create a
mouseover effect that changes the property
document.images['thefirst'].src = 'another_image.gif';
Usually you want to access forms to check what a user has filled in. For instance to read out what the user has filled in check the property value:
x = document.forms.elements.value;
and then check
x for whatever is necessary. See the
introduction to forms for details on how to access specific
form fields (checkboxes, radio buttons etc.).