There are a few things you need to keep in mind while writing an XML document, or else the RSS reader will not be able to understand it. It’s better to think of writing XML as writing code than text, because there are some strict syntax rules you need to adhere to.

Balance Opening and Closing Tags

One strict syntax rule of XML is that opening and closing tags must be balanced. For every opening tag, there must be a closing tag.

<item>
  <description>
</item>
 
<item>
  <description></description>
</item>

In this example, the first item element is invalid – because description has no closing tag. The second example is valid, because description is closed. You could also use a self-closing tag if description doesn’t contain a value.

<item>
  <description />
</item>

With a simple feed, it can be easy enough to keep tags balanced. However, it’s a good idea to look into using an XML parser like SimpleXML to build the feed. This ensures that the tags are balanced and that the XML is well-formed.

Ampersands Are Not Allowed

The lovely ampersand – & – is not allowed to appear in an XML document without being escaped (&).

If a browser or feed reader encounters an ampersand that isn’t escaped and that isn’t being used to form a valid entity, the application will simply stop reading. You might overlook this possible problem if your URLs use query strings – and thus have ampersands inside them.

The solution is to escape all of the URLs and data that is going into your feed. The reader will convert & back into & so that your links work correctly. PHP offers a function to help you do that.

$escapedText = htmlentities($unescapedText);

Pass all of the text that needs to be escaped (like your URLs) through the htmlentities function, and your problems will be solved. Incidentally, this will also escape > and < characters.

No Non-Breaking Spaces!

The final tip deals with invalid entities, like  . As mentioned before, ampersands are a strict no-no. They can be used to form entity codes, but they cannot be used by themselves.

If you attempt to create an entity that the XML processor doesn’t recognize, it won’t read it as an entity – it will read it as an ampersand with some text following. For example, &bob; would be read by an XML processor as an ampersand and the word “bob;”.

It would then promptly stop processing your feed.

One common way for this to break your feed is the non-breaking space character –  . These often serve no purpose in the document, but you might get them littered around your source code if you use a WYSIWYG editor.

You could get rid of these by filtering your output through a function that does a str_replace of   with ‘ ‘.

If the non-breaking space character serves a purpose in your document, you can preserve it for the browser but make the XML processor ignore it. This is where CDATA comes in.

<description><![CDATA[This is a description with content that
<strong>shouldn't</strong> be interpeted
by the &nbsp; XML processor.]]></description>

When you wrap text inside that tag – <![CDATA[ and ]]> – you tell the processor to ignore the text and spit it out as is. This can help your non-breaking space character make it to the user. You may also want to use this if your descriptions and content include HTML tags.

Browse the Spec

These are a couple of tips to help you address some of the more common things that will break your XML documents.

However, there are many other minor errors you can come across. The only way to learn about them and solve them is through two things – research and trial and error.

You may want to take some time to browse the XML specification as well as read forums for problems that other people have. Then, test things out and find out what doesn’t work.

This article will look at how to build a basic feed of data – for our purposes, we’ll consider random quotes. It will also illustrate how to use SimpleXML to build the feed for us.

The RSS 2.0 Standard

RSS feeds, like XML in general, have specific standards. In order to be use-able across platforms, it is imperative that standard syntax and naming patterns are used. If you’re unfamiliar with the RSS 2.0 standard, you should look through a copy here.

Before we get to building the feed, let’s identify what tags we’re going to use.

The entire feed is wrapped in an <rss> tag. Within that element is a <channel> element.

The <channel> element has a number of optional child elements. The basic ones we’ll want to include are – <title>, <description>, <link>, and <pubDate>.

The actual data (our random quotes) is wrapped in <item> elements. These also have a bunch of optional parameters. We’ll be using the basics – <title;>, <description>, and <pubDate>. Notice that there’s no link – because we’re feeding simple data, not articles!

Creating the SimpleXML Object

In order to create the SimpleXML object, you need to feed it some kind of XML string. Normally this would be a completed file or string – like an existing feed.

Since we’re building the feed with SimpleXML, we don’t have a lot to start with. We can give it a very basic string to create the object – an opening and closing rss element.

$xml = new SimpleXMLElement('<rss version="2.0"></rss>');

Adding Child Elements

The addChild() method of SimpleXML allows us to add child elements to existing elements. In addition to adding a child element, the method returns a reference to the new child – allowing us to manipulate it in turn.

The first child we’ll need to create is the channel element.

$channel = $xml->addChild('channel');

That creates the channel element and stores a reference to it in $channel. We can then use the $channel variable to add more children – the information defining the channel element itself.

$channel->addChild('title', 'Test Feed');
$channel->addChild('link', 'http://www.earn-web-cash.com');
$channel->addChild('description', 'This is a feed testing how to build an RSS feed in SimpleXML');
$channel->addChild('pubDate', date("D, d M Y H:i:s T"));

You may want to include other optional parameters that are included in the specification. Just add another $channel->addChild() call with the parameter’s name and its value.

Creating the Random Quote Items

At this point, we just need to add our item elements and we’re done. To do that, we’ll loop through an array of data, create an item element, and add the appropriate children to it.

Let’s assume that I retrieved information from a database table with three columns – title, description, and pubDate.

while ($row = mysql_fetch_array($result)) {
  $newItem = $channel->addChild('item');
  $newItem->addChild('title', $row['title']);
  $newItem->addChild('description', $row['description']);
  $newItem->addChild('pubDate', date("D, d M Y H:i:s T", $row['pubDate']));
}

Again, you can add extra data to your feed by adding extra child elements.

Outputting the Feed

Now that the entire feed is stored in the $xml variable, we just need to output it.

In doing this, we’ll do two things. We need to define the content-type as xhtml/xml. Then we use the asXML() method to print the information in an xml string.

header('Content-Type: application/xhtml+xml');
echo $xml->asXML();

You could alternatively save this to an xml file. There are two ways to do this – either file_put_contents the output from asXML() or pass a filename as the parameter for asXML().

file_put_contents($filename, $xml->asXML());
//  or ...
$xml->asXML($filename);

Start Feeding

With this basic script, you can serve up any kind of information as an RSS feed. This makes it easy for people to read it in their RSS readers or even access the information on the cell phones.

There are plenty of types of data you could use this for – quotes, jokes, question of the day, trivia, tip of the day, etc. By publishing tiny bits of data on a daily basis, you keep your users coming back for more – but you don’t need to publish full size articles every day.

In case you ran into trouble putting the script together, here’s the entire source code with an array of data built into it.

$items = array();
$items[] = array('title' => 'Mark Twain on Profanity', 'description' => 'Under certain circumstances, profanity provides a relief denied even to prayer.');
$items[] = array('title' => 'Woody Allen on People', 'description' => 'It seemed the world was divided into good and bad people. The good ones slept better... while the bad ones seemed to enjoy the waking hours much more.');
$items[] = array('title' => 'Will Rogers on Vets', 'description' => 'The best doctor in the world is the veterinarian. He can\'t ask his patients what is the matter - he\'s got to just know.');
 
//  Create the root element - RSS
$xml = new SimpleXMLElement('<rss version="2.0"></rss>');
 
//  Create the channel element, a child of RSS
$channel = $xml->addChild('channel');
 
//  Add random channel information
$channel->addChild('title', 'Random Quotes');
$channel->addChild('link', 'http://www.earn-web-cash.com');
$channel->addChild('description', 'This is a feed of random, interesting quotes.');
$channel->addChild('pubDate', date("D, d M Y H:i:s T"));
 
//  Loop through and create item elements
foreach ($items as $item) {
  $newItem = $channel->addChild('item');
  $newItem->addChild('title', $item['title']);
  $newItem->addChild('description', $item['description']);
}
 
//  Output
header('Content-Type: application/xhtml+xml');
echo $xml->asXML();

His parser wasn’t working – because all of the information was stored in attributes instead of child elements. What’s the difference between the two? And how can we fix it?

Use SimpleXML.

Difference Between a Child and an Attribute

For starters, let’s take a look at a sample XML file. This will help illustrate the difference between a child element and an attribute, and it will give us something to work with later on.

<?xml version="1.0" encoding="UTF-8"?>
 
<library>
  <book lang="en">
    <author>John Steinback</author>
    <title>Of Mice and Men</title>
  </book>
 
  <book lang="en">
    <author>F. Scott Fitzgerald</author>
    <title>The Great Gatsby</title>
  </book>  
</library>

This simple XML file is a “library.” It contains a list of books – each of which has an author, a title, and a “lang” attribute.

In this example, “book” is an element. It is a child element of library – which means it is an element created inside the open library element. You could also refer to the library element as the parent of all the book elements.

To create a child element, you simply create a set of tags within a larger set of tags. The book is a child of library, while the author is a child of book. We could create more children for “Author” – like age, sex, and hair color.

By contrast, “lang” is an attribute. It is defined inside the opening tag of an element. By declaring lang="en" we are saying that the book has the attribute of being written in English.

It is simply another (perhaps more annoying) way to store information in an XML file. Most basic XML parsers look for tags and content – but the attribute is neither. It’s contained inside a tag, so it needs to be handled specially.

Thankfully, SimpleXML is designed to help us do just that.

Loading the File in SimpleXML

I saved the xml file above in “xmltest.xml.” In my php script, I can load it into a SimpleXML object with this function call.

$xml = simplexml_load_file('xmltest.xml');

This creates a SimpleXML object which is a tree of connected objects. The root object represents the “library” element. It then has an array of children called “book,” and each “book” element has two children element of its own.

Using the SimpleXML object structure, we can access some pieces of our XML document like this.

var_dump($xml->book[0]); //  All of the info in Book 1
echo $xml->book[0]->author; // First book, John Steinbeck
echo $xml->book[1]->title; // Second book, The Great Gatsby

Accessing the Lang Attribute in the Object Tree

The initial question now resurfaces – how do we access an attribute, like the ‘lang’ attribute?

All of the elements are nicely arranged in a tree. The parent element has a child element, which has a child element, so on and so forth. We can easily access these as related objects like we did above.

The attributes are exploded into an array and attached to the element that they define. So, for example, we defined a ‘lang’ attribute for our book element. Therefore, the value of lang will reside in an array attached to that specific book element.

We can access it like this.

echo $xml->book[0]['lang']; // en

To find an attribute of an object with SimpleXML, you navigate to the element in question and then access an array indexed by the names of the attributes. In this case, our attribute was named ‘lang’ so we use ‘lang’ as a key in the array to get the value.

For simplicity’s sake, it is usually better to define all of your XML data as child elements. This allows you to easily expand data types in the future, and you won’t have to mix methods for accessing the data.

However, if you’re working with someone else’s XML file, you may need to look up attributes. Now you know how.