XML DOM Introduction

The XML DOM defines a standard for accessing and manipulating XML.

What You Should Already Know

Before you continue you should have a basic understanding of the following:
• HTML
• XML
• JavaScript
If you want to study these subjects first, find the tutorials on our Home page.

What is the DOM?

The DOM is a W3C (World Wide Web Consortium) standard.
The DOM defines a standard for accessing documents like XML and HTML:
"The W3C Document Object Model (DOM) is a platform and language-neutral interface that allows programs
and scripts to dynamically access and update the content, structure, and style of a document."
The DOM is separated into 3 different parts / levels:
• Core DOM - standard model for any structured document
• XML DOM - standard model for XML documents
• HTML DOM - standard model for HTML documents
The DOM defines the objects and properties of all document elements, and the methods (interface) to
access them.

What is the HTML DOM?

The HTML DOM defines the objects and properties of all HTML elements, and the methods (interface) to
access them.
If you want to study the HTML DOM, find the HTML DOM tutorial on our Home page.

What is the XML DOM?

The XML DOM is:
• A standard object model for XML
• A standard programming interface for XML
• Platform- and language-independent
• A W3C standard
The XML DOM defines the objects and properties of all XML elements, and the methods (interface) to
access them.
In other words: The XML DOM is a standard for how to get, change, add, or delete XML elements.
XML DOM Nodes

In the DOM, everything in an XML document is a node.

DOM Nodes
According to the DOM, everything in an XML document is a node.
The DOM says:
• The entire document is a document node
• Every XML element is an element node
• The text in the XML elements are text nodes
• Every attribute is an attribute node
• Comments are comment nodes

DOM Example
Look at the following XML file (books.xml):
<?xml version="1.0" encoding="ISO-8859-1"?>
<bookstore>
<book category="cooking">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
<book category="children">
<title lang="en">Harry Potter</title>
<author>J K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
<book category="web">
<title lang="en">XQuery Kick Start</title>
<author>James McGovern</author>
<author>Per Bothner</author>
<author>Kurt Cagle</author>
<author>James Linn</author>
<author>Vaidyanathan Nagarajan</author>
<year>2003</year>
<price>49.99</price>
</book>
<book category="web" cover="paperback">
<title lang="en">Learning XML</title>
<author>Erik T. Ray</author>
<year>2003</year>
<price>39.95</price>
</book>
</bookstore>
The root node in the XML above is named <bookstore>. All other nodes in the document are contained
within <bookstore>.
The root node <bookstore> holds four <book> nodes.
The first <book> node holds four nodes: <title>, <author>, <year>, and <price>, which contains one text
node each, "Everyday Italian", "Giada De Laurentiis", "2005", and "30.00".

Text is Always Stored in Text Nodes

A common error in DOM processing is to expect an element node to contain text.
However, the text of an element node is stored in a text node.
In this example: <year>2005</year>, the element node <year>, holds a text node with the value
"2005".
"2005" is not the value of the <year> element!

XML DOM Node Tree

The XML DOM views an XML document as a node-tree.

All the nodes in the tree have a relationship to each other.

The XML DOM Node Tree

The XML DOM views an XML document as a tree-structure. The tree structure is called a node-tree.
All nodes can be accessed through the tree. Their contents can be modified or deleted, and new elements
can be created.
The node tree shows the set of nodes, and the connections between them. The tree starts at the root node
and branches out to the text nodes at the lowest level of the tree:

The image above represents the XML file books.xml.

Node Parents, Children, and Siblings
The nodes in the node tree have a hierarchical relationship to each other.
The terms parent, child, and sibling are used to describe the relationships. Parent nodes have children.
Children on the same level are called siblings (brothers or sisters).
• In a node tree, the top node is called the root
• Every node, except the root, has exactly one parent node
• A node can have any number of children
• A leaf is a node with no children
• Siblings are nodes with the same parent
The following image illustrates a part of the node tree and the relationship between the nodes:

Because the XML data is structured in a tree form, it can be traversed without knowing the exact structure
of the tree and without knowing the type of data contained within.
You will learn more about traversing the node tree in a later chapter of this tutorial.

First Child - Last Child

Look at the following XML fragment:
<bookstore>
<book category="cooking">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
</bookstore>
In the XML above, the <title> element is the first child of the <book> element, and the <price> element is
the last child of the <book> element.
Furthermore, the <book> element is the parent node of the <title>, <author>, <year>, and <price>
elements.

XML DOM Parsing

Most browsers have a build-in XML parser to read and manipulate XML.
The parser converts XML into a JavaScript accessible object.

Parsing XML
The XML DOM contains methods (functions) to traverse XML trees, access, insert, and delete nodes.
However, before an XML document can be accessed and manipulated, it must be loaded into an XML DOM
object.
The parser reads XML into memory and converts it into an XML DOM object that can be accessed with
JavaScript.

Load an XML Document

The following JavaScript fragment loads an XML document ("books.xml"):
var xmlDoc;
xmlDoc=new window.XMLHttpRequest();
xmlDoc.open("GET","books.xml",false);
xmlDoc.send("");
Code explained:
• Create an XMLHTTP object
• Open the XMLHTTP object
• Send an XML HTTP request to the server

Load an XML String

The following code loads and parses an XML string:
try //Internet Explorer
{
xmlDoc=new ActiveXObject("Microsoft.XMLDOM");
xmlDoc.async="false";
xmlDoc.loadXML(txt);
return xmlDoc;
}
catch(e)
 {
parser=new DOMParser();
xmlDoc=parser.parseFromString(txt,"text/xml");
return xmlDoc;
}
Note: Internet Explorer uses the loadXML() method to parse an XML string, while other browsers use the
DOMParser object.

Access Across Domains

For security reasons, modern browsers do not allow access across domains.
This means, that both the web page and the XML file it tries to load, must be located on the same server.
The examples on W3Schools all open XML files located on the W3Schools domain.
If you want to use the example above on one of your web pages, the XML files you load must be located on
your own server.

XML DOM Load Functions

The code for loading XML documents can be stored in a function.

The loadXMLDoc() Function

To make the code from the previous page simpler to maintain (and check for older browsers), it should be
written as a function:
function loadXMLDoc(dname)
{
var xmlDoc;
if (window.XMLHttpRequest)
{
xmlDoc=new window.XMLHttpRequest();
xmlDoc.open("GET",dname,false);
xmlDoc.send("");
return xmlDoc.responseXML;
}
// IE 5 and IE 6
else if (ActiveXObject("Microsoft.XMLDOM"))
{
xmlDoc=new ActiveXObject("Microsoft.XMLDOM");
xmlDoc.async=false;
xmlDoc.load(dname);
return xmlDoc;
}
alert("Error loading document");
return null;
}
The function above can be stored in the <head> section of an HTML page, and called from a script in the
page.

The function described above, is used in all XML document examples in this tutorial!
An External JavaScript for loadXMLDoc()
To make the code above even easier to maintain, and to make sure the same code is used in all pages, we
store the function in an external file.
The file is called "loadxmldoc.js", and will be loaded in the head section of an HTML page. Then, the
loadXMLDoc() function can be called from a script in the page.
The following example uses the loadXMLDoc() function to load books.xml:

Example

<html>
<head>
<script type="text/javascript" src="loadxmldoc.js">
</script>
</head>
<body>

<script type="text/javascript">
xmlDoc=loadXMLDoc("books.xml");

code goes here.....

</script>

</body>
</html>

How to get the data from the XML file, will be explained in the next chapters.

The loadXMLString() Function

To make the code from the previous page simpler to maintain (and check for older browsers), it should be
written as a function:
function loadXMLString(txt)
{
try //Internet Explorer
{
xmlDoc=new ActiveXObject("Microsoft.XMLDOM");
xmlDoc.async="false";
xmlDoc.loadXML(txt);
return xmlDoc;
}
catch(e)
{
try //Firefox, Mozilla, Opera, etc.
{
parser=new DOMParser();
xmlDoc=parser.parseFromString(txt,"text/xml");
return xmlDoc;
}
catch(e) {alert(e.message)}
 }
return null;
}
The function above can be stored in the <head> section of an HTML page, and called from a script in the
page.

The function described above, is used in all XML string examples in this tutorial!

An External JavaScript for loadXMLString()

We have stored the loadXMLString() function in a file called "loadxmlstring.js".

Example

<html>
<head>
<script type="text/javascript" src="loadxmlstring.js"></script>
</head>
<body>
<script type="text/javascript">
text="<bookstore>"
text=text+"<book>";
text=text+"<title>Everyday Italian</title>";
text=text+"<author>Giada De Laurentiis</author>";
text=text+"<year>2005</year>";
text=text+"</book>";
text=text+"</bookstore>";

xmlDoc=loadXMLString(text);

code goes here.....

</script>
</body>
</html>

<html>
<head>
<script type="text/javascript" src="loadxmlstring.js"></script>
</head>
<body>
<script type="text/javascript">
text="<bookstore>"
text=text+"<book>";
text=text+"<title>Everyday Italian</title>";
text=text+"<author>Giada De Laurentiis</author>";
text=text+"<year>2005</year>";
text=text+"</book>";
text=text+"</bookstore>";
xmlDoc=loadXMLString(text);

code goes here.....

</script>
</body>
</html>

<html>

<head>

<script type="text/javascript" src="loadxmlstring.js"></script>

</head>

<body>

<script type="text/javascript">

text="<bookstore>"

text=text+"<book>";

text=text+"<title>Everyday Italian</title>";

text=text+"<author>Giada De Laurentiis</author>";

text=text+"<year>2005</year>";

text=text+"</book>";

text=text+"</bookstore>";

xmlDoc=loadXMLString(text);

document.write(xmlDoc.getElementsByTagName("title")[0].childNodes[0].nodeValue
);

document.write("<br />");

document.write(xmlDoc.getElementsByTagName("author")[0].childNodes[0].nodeVa
lue);

document.write("<br />");

document.write(xmlDoc.getElementsByTagName("year")[0].childNodes[0].nodeValu
e);
</script>

</body>

</html>

XML DOM - Properties and Methods

Properties and methods define the programming interface to the XML DOM.

Programming Interface
The DOM models XML as a set of node objects. The nodes can be accessed with JavaScript or other
programming languages. In this tutorial we use JavaScript.
The programming interface to the DOM is defined by a set standard properties and methods.
Properties are often referred to as something that is (i.e. nodename is "book").
Methods are often referred to as something that is done (i.e. delete "book").

XML DOM Properties

These are some typical DOM properties:

• x.nodeName - the name of x

• x.nodeValue - the value of x

• x.parentNode - the parent node of x

• x.childNodes - the child nodes of x

• x.attributes - the attributes nodes of x

Note: In the list above, x is a node object.

XML DOM Methods

• x.getElementsByTagName(name) - get all elements with a specified tag name

• x.appendChild(node) - insert a child node to x

• x.removeChild(node) - remove a child node from x

Note: In the list above, x is a node object.

Example
The JavaScript code to get the text from the first <title> element in books.xml:
txt=xmlDoc.getElementsByTagName("title")[0].childNodes[0].nodeValue
After the execution of the statement, txt will hold the value "Everyday Italian"
Explained:

• xmlDoc - the XML DOM object created by the parser.

• getElementsByTagName("title")[0] - the first <title> element

• childNodes[0] - the first child of the <title> element (the text node)

• nodeValue - the value of the node (the text itself)

XML DOM - Accessing Nodes

With the DOM, you can access every node in an XML document.

Try it Yourself - Examples

The examples below use the XML file books.xml.

A function, loadXMLDoc(), in an external JavaScript is used to load the XML file.
Access a node using its index number in a node list
This example uses the getElementsByTagname() method to get the third <title> element in "books.xml"
Loop through nodes using the length property
This example uses the length property to loop through all <title> elements in "books.xml"
See the node type of an element
This example uses the nodeType property to get node type of the root element in "books.xml".
Loop through element nodes
This example uses the nodeType property to only process element nodes in "books.xml".
Loop through element nodes using node realtionships
This example uses the nodeType property and the nextSibling property to process element nodes in
"books.xml".

Accessing Nodes
You can access a node in three ways:
1. By using the getElementsByTagName() method
2. By looping through (traversing) the nodes tree.
3. By navigating the node tree, using the node relationships.

The getElementsByTagName() Method

getElementsByTagName() returns all elements with a specified tag name.

Syntax
node.getElementsByTagName("tagname");
Example
The following example returns all <title> elements under the x element:
x.getElementsByTagName("title");
Note that the example above only returns <title> elements under the x node. To return all <title> elements
in the XML document use:
xmlDoc.getElementsByTagName("title");
where xmlDoc is the document itself (document node).

DOM Node List

The getElementsByTagName() method returns a node list. A node list is an array of nodes.
The following code loads "books.xml" into xmlDoc using loadXMLDoc() and stores a list of <title> nodes (a
node list) in the variable x:
xmlDoc=loadXMLDoc("books.xml");

x=xmlDoc.getElementsByTagName("title");
The <title> elements in x can be accessed by index number. To access the third <title> you can write::
y=x[2];
Note: The index starts at 0.
You will learn more about node lists in a later chapter of this tutorial.

DOM Node List Length

The length property defines the length of a node list (the number of nodes).
You can loop through a node list by using the length property:

Example

xmlDoc=loadXMLDoc("books.xml");

x=xmlDoc.getElementsByTagName("title");

for (i=0;i<x.length;i++)
{
document.write(x[i].childNodes[0].nodeValue);
document.write("<br />");
}

Example explained:

1. Load "books.xml" into xmlDoc using loadXMLDoc()

2. Get all <title> element nodes
3. For each title element, output the value of its text node
Node Types
The documentElement property of the XML document is the root node.
The nodeName property of a node is the name of the node.
The nodeType property of a node is the type of the node.
You will learn more about the node properties in the next chapter of this tutorial.
Try it yourself

Traversing Nodes
The following code loops through the child nodes, that are also element nodes, of the root node:

Example

xmlDoc=loadXMLDoc("books.xml");

x=xmlDoc.documentElement.childNodes;

for (i=0;i<x.length;i++)
{
if (x[i].nodeType==1)
{//Process only element nodes (type 1)
document.write(x[i].nodeName);
document.write("<br />");
}
}

Example explained:

1. Load "books.xml" into xmlDoc using loadXMLDoc()

2. Get the child nodes of the root element
3. For each child node, check the node type of the node. If the node type is "1" it is an element node
4. Output the name of the node if it is an element node

Navigating Node Relationships

The following code navigates the node tree using the node relationships:

Example

xmlDoc=loadXMLDoc("books.xml");

x=xmlDoc.getElementsByTagName("book")[0].childNodes;
y=xmlDoc.getElementsByTagName("book")[0].firstChild;
 for (i=0;i<x.length;i++)
{
if (y.nodeType==1)
{//Process only element nodes (type 1)
document.write(y.nodeName + "<br />");
}
y=y.nextSibling;
}

1. Load "books.xml" into xmlDoc using loadXMLDoc()

2. Get the child nodes of the first book element
3. Set the "y" variable to be the first child node of the first book element
4. For each child node (starting with the first child node "y"):
5. Check the node type. If the node type is "1" it is an element node
6. Output the name of the node if it is an element node
7. Set the "y" variable to be the next sibling node, and run through the loop again

<html>

<head>

<script type="text/javascript" src="loadxmldoc.js"></script>

</head>

<body>

<script type="text/javascript">

xmlDoc=loadXMLDoc("books.xml");

x=xmlDoc.getElementsByTagName("title");

document.write(x[2].childNodes[0].nodeValue);

</script>

</body>

</html>

<html>
<head>

<script type="text/javascript" src="loadxmldoc.js"></script>

</head>

<body>

<script type="text/javascript">

xmlDoc=loadXMLDoc("books.xml");

x=xmlDoc.getElementsByTagName("title");

for (i=0;i<x.length;i++)

document.write(x[i].childNodes[0].nodeValue);

document.write("<br />");

</script>

</body>

</html>

<html>

<head>

<script type="text/javascript" src="loadxmldoc.js"></script>

</head>

<body>

<script type="text/javascript">

xmlDoc=loadXMLDoc("books.xml");

document.write(xmlDoc.documentElement.nodeName);
document.write("<br />");

document.write(xmlDoc.documentElement.nodeType);

</script>

</body>

</html>

<html>

<head>

<script type="text/javascript" src="loadxmldoc.js"></script>

</head>

<body>

<script type="text/javascript">

xmlDoc=loadXMLDoc("books.xml");

x=xmlDoc.documentElement.childNodes;

for (i=0;i<x.length;i++)

if (x[i].nodeType==1)

{//Process only element nodes (type 1)

document.write(x[i].nodeName);

document.write("<br />");

</script>

</body>

</html>

<html>

<head>
<script type="text/javascript" src="loadxmldoc.js"></script>

</head>

<body>

<script type="text/javascript">

xmlDoc=loadXMLDoc("books.xml");

x=xmlDoc.getElementsByTagName("book")[0].childNodes;

y=xmlDoc.getElementsByTagName("book")[0].firstChild;

for (i=0;i<x.length;i++)

if (y.nodeType==1)

{//Process only element nodes (type 1)

document.write(y.nodeName + "<br />");

y=y.nextSibling;

</script>

</body>

</html>