As a ColdFusion developer, hopefully by now you have heard at least a little about XML (eXtensible Markup Language). Wikipedia defines XML as a "general-purpose markup language" designed to "facilitate the sharing of data" and also designed to be "relatively human-legible."

If you need primer on the basics of what XML is and the rules of how it's structured, a good place to start is http://en.wikipedia.org/wiki/XML.

Nowadays we see XML in regular daily use. RSS Feeds, podcasts, and Web Services are all XML, or use XML to exchange information. Even HTML is related and basically a type of XML (loosely, but that's a long discussion for another time). It's no coincidence that we see XML in use for mass-distributed or syndicated content - XML is designed for a few key purposes: 1) as a format that can easily be interpreted by software, and 2) containing only the data and its structure, with no formatting.

A complete collection of data as shown in Listing 1 is called an XML Document. XML Documents should be "well-formed" - meaning that they conform to all the rules of XML syntax, with no unclosed tags. (Note: The "<street2/>" element, which is empty, uses a trailing slash denoting that it is an empty element. This is essentially the same thing as typing out "<street2> </street2>.")

XML Documents that are meant to comply to a standard format will have an XML Schema definition, or a DTD (Document Type Definition), which defines a tight set of rules as to which content and tags can and can't be contained in an XML Document of that type. XML Documents are considered "valid" if they conform to their DTD, although for individual sites, many XML documents will not have a DTD and having one is not required.

So how do ColdFusion programmers use and work with XML? ColdFusion is supposed to empower programmers to build sites and Web applications faster, right? So what tools are available to help us get the job done faster when it comes to XML? That's the primary focus of this article. We'll focus on the building blocks of how ColdFusion works with XML and then show how to use some of the other useful functions.

The built-in functions in CFML that we'll be covering are Xml Parse(), XmlNew(), XmlElemNew(), XmlSearch, and XmlValidate().

Reading XML Documents
Reading and using data from an XML document is the first, and easiest, lesson. The key to coding a project that uses XML is understanding the mechanics of XML. In the past (pre-XML days) if we wanted to pull data from inside text (such as a first name from the data in Listing 1), we'd have needed to search the string and use mid() functions to extract what we want. This is a tedious process. Now with XML we can translate a well-formed XML document into something ColdFusion can understand. We use the XmlParse() function to convert this from structured text into an XML Object, which is basically a collection of structures and arrays.

Take a look at Listing 2 and Listing 3. In this example, we read details of an order in XML format and display the results, formatted with HTML.

On line 1, we read the contents of the XML document into a string named strXmlOrder. In this example we are reading a file from the local file system, however, you could have just as easily read this data from a database or a remote server using CFHTTP or a Web Service call.

On line 5 we parse the XML using XmlParse(). This function transforms the XML from its textual form into a ColdFusion XML Object called XmlOrder. Try doing a <cfdump var="#XmlOrder#"> here and take a look at the results. What you'll see is that the XmlOrder object is an organized collection of structures and arrays.

The XML Object is organized as a tree of XML Elements (an element is an opening and closing tag and any of its contents - including other elements) and attributes (values that are part of the opening tag).

Look again at Listing 2 and let's put things into perspective:
<order> is the xmlroot, and also happens to be an XML Element because it has an opening and closing tag. The <order ... > element has one attribute called "id," which has a value of "E10645."

The <customer ...>, <items>, and each of the <item> tags are also XML Elements. "Fname," "lname," and "memberid" are attributes of the <customer ...> element and so on; you get the idea.

Under the xmlroot element, all other "children" elements are organized in an array called XmlChildren. So <customer...> and <items> are both children of <order>, and as such are stored in the XmlChildren array, as element 1 and 2 accordingly.

The Items element has three children elements (the three individual items), and each of those items has three children elements (name, quantity, and price).

Now that you have a feel for how this data is organized, let's go back to Listing 3.

On line 11 we display the order id. Since "id" is an attribute of the <order ...> element, it's neatly put in a structure called XmlAttributes. So we can reference it like so:

XmlOrder.order.XmlAttributes.id

Since the <order> element also happens to be the xmlroot, we can reference the same attribute like so:

XmlOrder.xmlroot.XmlAttributes.id

Since XmlAttributes is a standard ColdFusion structure, any functions for struct manipulation will work on it as well, so for example if you wanted to retrieve the list of attributes from the <order...> element, you could use StructKeyList(XmlOrder.order.XmlAttributes).

On lines 15 and 19, attributes of the <customer ...> element are displayed. The customer element is a child of xmlroot, so we refer to it as "XmlOrder.xmlroot.XmlChildren[1]" (the array index is 1 since it appears as the first child of the xmlroot), or we can refer to it by a name like "XmlOrder.xmlroot.customer." To access attributes of the customer element we simply refer to the XmlAttributes struct.

Jump down to line 30 where we are doing a loop over each item in the <items> element. Since each <item> is a child of <items>, it is organized in an array called XmlChildren. Unlike the previous example, we can't refer to each of the items by its name because there are three elements with the same name. Instead, since XmlChildren is an array, we just loop over the array and refer to each <item> with its array index.