Will Fitch’s Blog

With the increasing use of web services and communications via HTTP, XML has become an industry standard for sending and receiving data among systems. Every language seems to have multiple ways to parse XML, each more complicated than the other. This presents a problem for developers.

The majority of the time, developers need to read/write XML files without complex features such as advanced namespacing and XSD validation. It seems that opening an XML file, reading and using the content takes forever as you constantly need to reference hundreds of pages of documentation, Google examples of each method or function in the documentation; it never ends.

Since the release of PHP5, SimpleXML has been available for creating and editing XML files or strings. Don’t let the name fool you, it doesn’t represent the simplicity of its capabilities. It does, however, mean the implementation of this extension is simple! PHP has other XML capabilities such as DOM, XMLWriter and XMLReader in the event you need those advanced features not offered by the native SimpleXML extension.

Configuring PHP to Use SimpleXML

SimpleXML is an extension that was added as of PHP 5 and requires no special libraries. If for some reason you wish not to have SimpleXML available to your PHP configuration, you can disable it at compile-time using --disable-simplexml. The primary class you will work with is called SimpleXMLElement.

There are Four Ways to Get an Instance of SimpleXMLElement:

1. simplexml_load_file - Load an XML document from a file. You may also access a remote file (HTTP for example).
2. simplexml_load_string - Load and XML string. Please keep in mind the XML needs to be well-formed.
3. SimpleXMLElement - Directly instantiate the SimpleXMLElement class. This requires a parameter starting the XML document. If you directly instantiate this class, you are typically using SimpleXML for XML output.
4. simplexml_import_dom - Returns and instance of SimpleXMLElement from a DOM object. That’s right, you can bring over that advanced object and make life simple!

Sample XML File Used

The following XML data will be contained in the referenced “test_file.xml”:

	
		Mustang
	
	
		Accord
	

Loading XML Data Using simplexml_load_file

This function is typically used for loading XML data either from a file, or a remote call. In this example, we will load a flat XML file:

That’s it. No need to clean anything up, PHP will take care of that for you.

Loading XML Using simplexml_load_string

	
		Mustang
	
	
		Accord
	

‘;
$xml = simplexml_load_string($xml);
?>

Pretty easy, huh? This function loads an XML string and returns and instance of SimpleXMLElement. You could also directly instantiate the SimpleXMLElement class a similar way, as demonstrated below.

Loading XML Using the SimpleXMLElement Class

	
		Mustang
	
	
		Accord
	

‘;
$xml = new SimpleXMLElement($xml);
?>

It’s your choice on using this method, or simplexml_load_string.

Loading XML Data Using simplexml_import_dom

	
		Mustang
	
	
		Accord
	

‘;
$dom = new DOMDocument;
$dom->loadXML($xml);
$xml = simplexml_import_dom($dom);
?>

This is handy when you are working with the advanced XML features of DOM. When you’re ready to move from those precocious features, just load the DOM object into simplexml_import_dom, and start programming the easy way!

Loading XML Data Using simplexml_load_file

All nodes are referenced as properties, and node attributes are within an associative array in each of those properties.
If there are multiple nodes with the same name ( in this example), you will need to specify the index value to reference.  This is done as an array index.  The following code refences the "name" attribute in the first  node
*/
echo $xml->make[0]['name'];
// Prints out "Ford" (without quotes)
?>

The above example print out “Ford”. We referenced the first node, and then printed out the “name” attribute. Now, let’s print out “Mustang” from the node.

make[0]->model;
// Prints out "Mustang" (without quotes)
?>

Reading XML doesn’t get any easier. The object-oriented design provided by SimpleXML makes code very elegant and maintainable.

The above examples assume you know exactly which node, down to the index, that contains the data you need to access. In the real world, this is an unlikely scenario. Normally, a developer knows the node names they are working with, but do not know (nor care) as to the number of those nodes.

Just like with normal arrays, we can count the number of elements. We will do this prior to iterating over the node. Let’s iterate!

	
		Mustang
	
	
		Accord
	
‘;
$xml = simplexml_load_string($xml);
if (count($xml->make) > 0) {
    foreach ($xml->make as $node) {
        // This prints out each of the models
    	echo $node->model.chr(10);
    }
}
?>

Important Information Regarding Values Returned from SimpleXML

If you have debugged any of these examples, you would have noticed that everything, nodes and attributes, are an instance of SimpleXMLElement. This may or may not be a feature in your opinion, but it’s the nature of SimpleXML. If you plan on storing any of these node/attribute values, you will need to typecast them:

make[0]->model;
// This converts the "Mustang" SimpleXMLElement object to a string, making it disk storable.
?>

You should certainly keep this in mind as you are working with this extension.

Writing XML with SimpleXML

Writing or producing XML is just as easy as reading it. While you can add additional data to existing XML files, the examples in this section will create fresh XML data. In part two, we will discuss more advanced options such as DOM, CDATA and namespaces. Now, on to writing XML data.

You will quickly learn that SimpleXML expects well-formed XML. There are two PHP functions you should familiarize with if you are not already:

1. utf8_encode - encode a string with UTF-8 standards.
2. htmlspecialchars - encode HTML characters with their proper entities.

You will need to use htmlspecialchars followed by utf8_encode to ensure proper data encoding. The following example illustrates using this technique to ensure proper XML output:

‘);
$make = $xml->addChild(’make’);
$make->addAttribute(’name’,'Ford’);
$make->addChild(’model’,htmlspecialchars(utf8_encode($some_db_variable)));
$xml->asXML();
// This will output the XML
?>

In order to create a new instance of SimpleXMLElement for writing, you will need to specify the top parent node. No need for the XML declaration, SimpleXML will add this for you. In the above example, we ensured that data coming from a database variable had non-UTF8 encoded characters encoded, and HTML entities properly converted. We also introduced a few additional methods. Let me explain:

The addChild method adds a new child to an existing node. This takes an optional second parameter of the value to place inside that node.

Each time you create a new child, a reference to the SimpleXMLElement is returned for use. Here, you can add additional child nodes, attributes and more. The initial SimpleXML object ($xml in the above example) contains the primary instance. You will use this object to output the data.

The addAttribute method adds an attribute to a node. If you aren’t sure of the data being added to the attribute (and just to be safe), you should also encode that value.

The asXML method saves/outputs the XML to the proper buffer. If you specify a file name in this method, the XML will be written to it. Here is an example:

‘);
$make = $xml->addChild(’make’);
$make->addAttribute(’name’,'Ford’);
$make->addChild(’model’,htmlspecialchars(utf8_encode($some_db_variable)));
$xml->asXML(’test_file.xml’);
// This will save the XML to a file called test_file.xml
?>

Conclusion

Through examples and definitions, you have familiarized yourself with the basics of SimpleXML. In part two (which is written yet), I will explain more advanced features of SimpleXML and DOM.

If you have any questions, feel free to post comments.

Will