Parsing XML files with Objective-C

Share this article

Perhaps the simplest app to create is a blog feed reader. Typically you will not find a native mobile app that’s there only to display a feed. Normally, this is a task best left for a website or a web-based application. Starting with the basics, RSS feeds are typically XML, which uses special tags to tell the page what type of information is being displayed. For example, instead of in text displaying “Author: Joe Shmoe”, the code would look more like

<author>Joe Shmoe</author>
The first format is more friendly to someone viewing the XML file in the browser and the other is more friendly to search engines and browsers. The other advantage to using XML over plain text is that it is easy to break it down into the individual parts rather than only looking at text to split the file apart. We are going to be looking at “Books.xml.” How do we do this in our apps then? Let’s start up XCode and get to work. First, lets create a new project, I named mine RSSFeed –Note I am running XCode 4.2  on Mac OSX Lion which is the latest version. So it may look slightly different for you – When setting up the project, select “Single View Application” as the project type and make sure Automatic Reference Counting (ARC) is not checked. This will set us up with a view controller, an app delegate, and an nib file. Nib files are the visual side of the application.

Create a new project in Xcode 4

We need to create a file to hold the information of the current item we are looking at, which in this case would be a book. so we need to create a new subclass of NSObject. To do so, go to File -> New -> New File. Under iOS select the cocoa touch section then choose Objective-C class.

Add a new Objective-C class

I named mine Book. There are four items that we need to store based on the XML file: author, title, summary, and the book index. Author, title and summary are all strings, while the book index is an integer. This is a very simple object and only consists of variables to store data, no methods are necessary outside of the dealloc function. Just like in any other application, we need to create the variables in the header file and create the properties for them. Then in the implementation file, we need to synthesize those variables and release them in the dealloc function. Here is how they should look.
// Book.h
#import <Foundation/Foundation.h>

@interface Book : NSObject {
    NSInteger bookID;
    NSString *author;
    NSString *title;
    NSString *summary;

@property (nonatomic, readwrite) NSInteger bookID;
@property (nonatomic, retain) NSString *author;
@property (nonatomic, retain) NSString *title;
@property (nonatomic, retain) NSString *summary;

// Book.m
#import "Book.h"

@implementation Book

@synthesize author, title, summary, bookID;

- (void) dealloc
    [author release];
    [summary release];
    [title release];
    [super dealloc];

Now that we have that set up, lets create the parser file. We need to go through the same process to create a new Objective-C based class, call this one rssParser. The following code should be added to the rssParser.h file:
#import <UIKit/UIKit.h>

@class Book, AppDelegate;

@interface rssParser : NSObject <NSXMLParserDelegate>{

    Book *book;
    AppDelegate *appdelegate;

    NSMutableString *curElem;


@property (nonatomic, retain) Book *book;
@property (nonatomic, retain) AppDelegate *appdelegate;
@property (nonatomic, retain) NSMutableString *curElem;

- (rssParser*) initXMLParser;

As you can see, this file uses the UIKit framework. Right below that you have what are called wrapper classes. When you use wrapper classes you are allowing your class to access not only methods, but variables of those classes, which in this case are Book and AppDelegate. In order to reach those variables and methods, we need to create instances of those classes. That is what Book *book; AppDelegate *appdelegate; accomplishes. Then we create a string to hold the current element. Just like before, we need to add the properties and then synthesize the variables. I know this is a bit dry right now, but it is the basic setup to get everything working. You will also see the method declaration for the initXMLParser function which we will get into next. Now we have to connect the pieces within the rssParser class’s implementation file. Add the following headers to the top of rssParser.m to connect the files together: AppDelegate.h and Book.h. Remember that initXMLParser function we declared? Well here is the code that makes up that function. As I’m sure you are able to tell, this method initializes all of the parts necessary to run the parser. First you initialize the parser itself, and then the AppDelegate. Let’s jump over to the AppDelegate.h and AppDelegate.m files to insert a little more code before getting a better idea of what is going on here. Starting in AppDelegate.h, add the following code:
- (rssParser *) initXMLParser
    [super init];

    appdelegate = (AppDelegate *)[[UIApplication sharedApplication] delegate];

    return self;
This should not be too different from what the file was originally created with. In reality the only lines of code that have been added to the file is the creation and property of an NSMutableArray called books. Here is the instead of recreating the whole file, only three things need to happen.
  • We need to add a reference to the rssParser.h file so we can have access to it.
  • We need to synthesize our books array
  • Connect the dots and make everything work.
Add the following to the application didFinishLaunchingWithOptions function right after the first line of code in the function.
NSURL *url = [[NSURL alloc] initWithString:@""];
NSXMLParser *xmlparser = [[NSXMLParser alloc] initWithContentsOfURL:url];

rssParser *parser = [[rssParser alloc] initXMLParser];

[xmlparser setDelegate:parser];

BOOL success = [xmlparser parse];

	NSLog(@"No Errors");
	NSLog(@"Error Error Error!!!");

Time to break the code apart. Any time you work with a file within Objective-C you have to reference using a variable of NSUrl data type. Since we are using a file that is not contained within the app, we can initialize that URL using a string. Now we need to create a parser, but note: we are not using the rssParser class yet. Objective C has a built in XML parsing class called NSXMLParser. We are able to use the URL we created to pass the file into the parser to eventually be processed by the application.

In order to move any farther we need to initialize our rssParser class using the initXMLParser function that we created earlier. Also, remember in rssParser.h we had to declare it as an XMLParserDelegate, here is where we apply that to the XML Parser. The purpose of the delegate is to override basic functionality to give custom processing to the parser, but we will get into that in a few minutes. The last couple lines of code here check to see if the parsing was successful and adds a message to the log within XCode as proof. Note that we use the xmlparser variable to call the parse function. Normally this is run by basic functionality, but we want to customize it. So now we need to jump back into rssParser.m and add the functions to parse the information. This delegate will override three methods that come from the XMLParser class: didStartElement, foundCharacters, and didEndElement.
-(void) parser:(NSXMLParser *)parser didStartElement:(NSString *)elementName namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qualifiedName attributes:(NSDictionary *)attributeDict
    if([elementName isEqualToString:@"Books"]) {
        //Initialize the array.
        appdelegate.books = [[NSMutableArray alloc] init];
    else if([elementName isEqualToString:@"Book"]) {

        //Initialize the book.
        book = [[Book alloc] init];

        //Extract the attribute here.
        book.bookID = [[attributeDict objectForKey:@"id"] integerValue];

        NSLog(@"Reading id value :%i", book.bookID);

    NSLog(@"Processing Element: %@", elementName);
This function handles what to do when an element is found. In the XML file we are referencing, “Books” is the name of the feed wrapper. So if this is the element that has been found, then it is the start of the file so we initialize the books array we created within the AppDelegate. “Book” (non-plural) is the declares an individual item within the file. Now is when we need to store the data locally within the Book object. Also note that this process records the start of the parsing process within the log file in XCode. Now we move on to the foundCharacters method.
- (void)parser:(NSXMLParser *)parser foundCharacters:(NSString *)string {

        curElem = [[NSMutableString alloc] initWithString:string];
        [curElem appendString:string];

    NSLog(@"Processing Value: %@", curElem);

This function is simply used to store the value of the elements as they are bing processed and write them to the log. And for the end of the element:
- (void)parser:(NSXMLParser *)parser didEndElement:(NSString *)elementName
  namespaceURI:(NSString *)namespaceURI qualifiedName:(NSString *)qName {

    if([elementName isEqualToString:@"Books"])

    if([elementName isEqualToString:@"Book"]) {
        [appdelegate.books addObject:book];

        [book release];
        book = nil;
        [book setValue:curElem forKey:elementName];

    [curElem release];
    curElem = nil;

This function does a couple things. First it checks for the wrapper element again. This time, if it is found, it ends the parsing process. If the parser finds the book element again, it takes all of the information found in that element and adds it to the array of books, and then clears the value stored in curElem, to be used by the next element in line. Lets re-cap what this application does from the view of the application process. First, when the application loads, we declare where the XML file is located, create an instance of the XML parser, and push the XML file into the parser.

We wanted to override the normal parsing functionality, so we set the delegate to our rssParser delegate that we created. Within that delegate we override the three functions for processing an XML file: didStartElement, foundCharacters and didEndElement. Within these functions we reference our Book object to temporarily store whatever information is found, write the process to the output log, and when the element has been fully parsed, add the collection of data to an array that could be used later. Go ahead and run your code now and open the output log in XCode to see whether or not your code has worked successfully. At the end of those logs you should see “No Error” in bold text and you will also see all of the elements that have been processed from the xml file. From this point there are many ways to display your XML feed, so let your creativity run wild!

Frequently Asked Questions (FAQs) about Parsing XML Files with Objective-C

What is the significance of using Objective-C for parsing XML files?

Objective-C is a powerful, object-oriented language that is primarily used for developing software for iOS and OS X. It is a superset of the C programming language, which means it can use C libraries, including those for parsing XML files. This makes it a versatile choice for developers. Moreover, Objective-C has a dynamic runtime, which allows for greater flexibility in programming, including the ability to override methods and manipulate objects in ways that are not possible in statically typed languages.

How does the NSXMLParser work in Objective-C?

NSXMLParser is a SAX parser provided by the Foundation Framework in Objective-C. SAX stands for Simple API for XML. Unlike a DOM parser, which loads the entire XML document into memory, a SAX parser reads the XML document sequentially from start to end, generating events as it encounters tags and data. This makes it more memory-efficient, especially for large XML documents. NSXMLParser provides methods for setting the delegate object that will handle these events, and for starting and stopping the parsing process.

What are the common challenges faced while parsing XML files in Objective-C?

Parsing XML files in Objective-C can be challenging due to several reasons. XML files can be large and complex, with deeply nested elements and attributes. This can make the parsing process slow and memory-intensive. Moreover, XML files may contain special characters or entities that need to be correctly handled. Errors in the XML file, such as missing end tags or mismatched tags, can also cause the parser to fail.

How can I handle errors while parsing XML files in Objective-C?

NSXMLParser provides methods for error handling. The parser’s delegate can implement the parser:parseErrorOccurred: method to handle parsing errors. This method is called when the parser encounters a fatal error. The delegate can also implement the parser:validationErrorOccurred: method to handle validation errors. These methods are passed an NSError object that contains details about the error.

Can I parse XML files in Objective-C without using the NSXMLParser?

Yes, there are several other libraries and frameworks available for parsing XML files in Objective-C. These include libxml2, a powerful and highly configurable C library for parsing XML; and TouchXML, a lightweight and easy-to-use Objective-C library for parsing XML. These libraries provide different APIs and features, so you can choose the one that best fits your needs.

How can I improve the performance of XML parsing in Objective-C?

There are several strategies for improving the performance of XML parsing in Objective-C. One is to use a SAX parser like NSXMLParser, which is more memory-efficient than a DOM parser. Another is to use a streaming parser, which reads the XML file in chunks and processes each chunk as it is read. This can significantly reduce memory usage and improve speed. Also, optimizing the structure of the XML file, such as reducing the depth of nesting and the number of attributes, can also improve parsing performance.

How can I parse XML files with namespaces in Objective-C?

NSXMLParser provides methods for handling XML namespaces. The parser’s delegate can implement the parser:didStartMappingPrefix:toURI: method to handle the start of a namespace prefix-URI mapping, and the parser:didEndMappingPrefix: method to handle the end of a namespace prefix-URI mapping. These methods are passed the prefix and the URI of the namespace.

How can I parse XML files with CDATA sections in Objective-C?

NSXMLParser provides a method for handling CDATA sections. The parser’s delegate can implement the parser:foundCDATA: method to handle CDATA sections. This method is passed an NSData object that contains the CDATA section.

How can I parse XML files with comments in Objective-C?

NSXMLParser provides a method for handling comments. The parser’s delegate can implement the parser:foundComment: method to handle comments. This method is passed a string that contains the comment.

How can I parse XML files with processing instructions in Objective-C?

NSXMLParser provides a method for handling processing instructions. The parser’s delegate can implement the parser:foundProcessingInstructionWithTarget:data: method to handle processing instructions. This method is passed the target and the data of the processing instruction.

Tyler HermanTyler Herman
View Author
ios tutorialsObjective-C
Share this article
Read Next
Get the freshest news and resources for developers, designers and digital creators in your inbox each week
Loading form