← Back to PHP Course | Chapter 14: Advanced PHP | Lesson 24 of 24

PHP DOM Parser

The DOM (Document Object Model) extension parses an XML document into a full, navigable tree structure -- similar in spirit to SimpleXML, but with a richer, more standardized API that also supports modifying the document and writing it back out, making it the better choice when you need to build or edit XML, not just read it.

In this page:

  1. Loading an XML Document into DOM
  2. Finding Elements by Tag Name
  3. Reading Element Attributes
  4. Creating and Modifying XML with DOM
  5. Saving the Modified Document
Syntax
php 
$dom = new DOMDocument();
$dom->loadXML($xml_string);   // or $dom->load("file.xml")

$nodes = $dom->getElementsByTagName("tag_name");
$value = $node->getAttribute("attribute_name");

Loading an XML Document into DOM

new DOMDocument() creates a new, empty DOM document object, and its load() method (for a file) or loadXML() method (for a string) parses XML content into that object's tree structure, ready for navigation or modification.

Note: Check the return value of load()/loadXML() (both return false on failure) before attempting to work with the document further.
Warning: DOM emits PHP warnings for malformed XML by default rather than throwing exceptions -- wrap loading in libxml_use_internal_errors(true) if you want to handle parse errors more gracefully.

Example: Loading an XML Document into DOM

php 
<?php
// Create a new `DOMDocument` instance, stored in `$dom`
$dom = new DOMDocument();
$dom->loadXML("<catalog><book>PHP Basics</book></catalog>");
// Print `get_class($dom)` to the output
echo get_class($dom);
?>

Finding Elements by Tag Name

getElementsByTagName($tagName) searches the entire document for every element matching that tag name, anywhere in the tree, returning a DOMNodeList you can loop over -- similar in spirit to an XPath query, but simpler for the common case of "find all X".

Note: Use getElementsByTagName() as your default way to find every instance of a specific tag, regardless of how deeply nested it is in the document.
Warning: getElementsByTagName() searches the whole document by default when called on the DOMDocument itself, but searches only within a specific element's descendants when called on that element instead -- be clear about which scope you intend.

Example: Finding Elements by Tag Name

php 
<?php
// Create a new `DOMDocument` instance, stored in `$dom`
$dom = new DOMDocument();
$dom->loadXML("<catalog><book>A</book><book>B</book></catalog>");
// Declare `$books`, set to `$dom->getElementsByTagName("book")`
$books = $dom->getElementsByTagName("book");
// Loop over `$books`, binding each item to `$book`
foreach ($books as $book) {
    // Print `$book->nodeValue . "\n"` to the output
    echo $book->nodeValue . "\n";
}
?>

Reading Element Attributes

A DOM element node's getAttribute($name) method reads a specific attribute's value directly, while hasAttribute($name) checks whether it exists at all -- straightforward, explicit methods for working with XML attributes in the DOM API.

Note: Check hasAttribute() first if an attribute might legitimately be missing, since getAttribute() on a missing attribute simply returns an empty string rather than null or an error.
Warning: getAttribute() returning an empty string is ambiguous between 'the attribute doesn't exist' and 'the attribute exists but is set to an empty string' -- use hasAttribute() when that distinction matters.

Example: Reading Element Attributes

php 
<?php
// Create a new `DOMDocument` instance, stored in `$dom`
$dom = new DOMDocument();
$dom->loadXML('<book id="1">PHP Basics</book>');
// Declare `$book`, set to `$dom->getElementsByTagName("book")->item(0)`
$book = $dom->getElementsByTagName("book")->item(0);
// Print `$book->getAttribute("id") . "\n"` to the output
echo $book->getAttribute("id") . "\n";
// Print a detailed dump (with types) of `$book->hasAttribute("author")`
var_dump($book->hasAttribute("author"));
?>

Creating and Modifying XML with DOM

Unlike SimpleXML's more limited editing support, DOM offers a full set of methods for building an XML document from scratch: createElement() creates a new element, appendChild() attaches it to a parent, and setAttribute() adds an attribute -- letting you construct or modify a document programmatically.

Note: Build a new XML document by creating elements one at a time and appending them in the order you want them to appear, working from the root element downward.
Warning: A newly created element with createElement() exists only in memory until it is actually appended somewhere in the document tree with appendChild() -- creating it alone has no visible effect.

Example: Creating and Modifying XML with DOM

php 
<?php
// Create a new `DOMDocument` instance, stored in `$dom`
$dom = new DOMDocument();
// Declare `$book`, set to `$dom->createElement("book", "PHP Basics")`
$book = $dom->createElement("book", "PHP Basics");
$book->setAttribute("id", "1");
$dom->appendChild($book);
// Print `$dom->saveXML()` to the output
echo $dom->saveXML();
?>

Saving the Modified Document

saveXML() returns the entire document (or a specific node) as an XML string, and save($filename) writes it directly to a file -- either way, changes made to the DOM tree only take effect in the actual output once one of these methods is called.

Note: Call saveXML() or save() as the final step after any DOM modifications, since the in-memory tree changes are invisible outside the script until then.
Warning: Modifying a DOM tree and forgetting to call saveXML() or save() afterward means the changes exist only in memory for the duration of the script and are never actually output or persisted.

Example: Saving the Modified Document

php 
<?php
// Create a new `DOMDocument` instance, stored in `$dom`
$dom = new DOMDocument();
// Declare `$book`, set to `$dom->createElement("book", "PHP Basics")`
$book = $dom->createElement("book", "PHP Basics");
$dom->appendChild($book);
$dom->save("output.xml");
// Print `file_get_contents("output.xml")` to the output
echo file_get_contents("output.xml");
?>
Related Topics

PHP XML Expat Parser · PHP SimpleXML Parser · PHP SimpleXML Get · PHP Iterables

{# common_mistakes/chapter_summary/browser_support: on Hindi pages the view already swaps in the hi_ translation fields (or blanks these out if untranslated), so this renders correctly for both languages without a lang_code check here. #}
Common Mistakes
  1. Reaching for DOM when SimpleXML would be simpler and sufficient for a straightforward read-only parsing task -- DOM's extra power comes with noticeably more verbose code.
  2. Forgetting to call saveXML() (or save() for a file) after modifying a DOM document -- changes made to the in-memory tree do not automatically persist anywhere on their own.
  3. Confusing DOM's own node-tree navigation methods (childNodes, getElementsByTagName) with SimpleXML's simpler property-based access -- the two APIs are not interchangeable.
Chapter Summary
  • DOMDocument::load() or loadXML() parses an XML file or string into a full DOM tree.
  • getElementsByTagName() finds all elements with a given tag name anywhere in the document.
  • DOM supports creating and modifying elements, then writing the changed document back out with saveXML() or save().
Browser Support

The DOM extension has been a core part of PHP since PHP 5 and is enabled by default in most standard installations.

🔒

Chapter Quiz — Complete all 24 topics to unlock

0/24 topics done

Complete these topics first:

← Previous Lesson PHP XML Expat Parser Next Lesson → PHP cURL Introduction

Login to run this code

C/C++/Java/PHP execution requires a free account. Your code is saved — you'll land right back in the editor after logging in.