Advanced Strings In Cocoa

I've been asked many times how Strings work on Mac and iPhone and why certain things work the way the do. It's not difficult, but there is a lot, so I decided to organize my thoughts into this little document. Perhaps, it will even help someone. Please let me know if it does. [Vlad]

Introduction

In my 15 years as a software developer, I did not write a single program that did not have to parse, search, or modify strings. As mundane as his subject may sound, it is one of the cornerstones of software development.

Today, there are libraries that will do almost anything for us. For example, we could just borrow open-source Google code to handle ATOM feeds, etc. Then why do we need to know all this? Very often, we don’t, but when we do, the problem can be very complicated and we need to be prepared to handle it. Libraries are written against the standards and there are often situations when we have to deal with deviations from standards. One of my clients had created an XML-RPC service, but was putting non-standard dates in it. Another, wanted to remove specific HTML formatting from its RSS feeds, but in such a way that it would not significantly degrade the performance of the program. Also, what if you needed to format dates, extract paragraphs, create summaries from an arbitrary content, and more? My goal is to help you to prepare to handle those problems and to show you where to look for information.
The beauty of Cocoa is that it is totally interoperable with native C libraries. This is important for a couple of reasons:

• it gives us access to the Standard C library functions
• certain operations on strings are more efficient when done natively

The C Library brings us additional functionality, such as regular expression handling. It is also useful when simple pointer arithmetics needs to be used to improve the performance of a program, for example scanning a string for a given character. While native functions can be used with Unicode characters, Unicode operations are by no means trivial. Cocoa brings its own set of classes, NSString and NSMutableString, to the table. These classes make unicode support transparent to the user and provide simple conversions to and from various formats. This is important, because the content received from the internet, such as RSS feeds, may be supplied in a variety of formats and we have to be able to process all that data.

A thing to remember: native C strings are NULL-terminated, whereas Cocoa strings are not.

NSString and NSMutableString

NSString is an immutable string wrapper. What it means, is that once an NSString object has been instantiated it cannot be modified.

NSMutableString, as the name suggests, is a mutable string wrapper, i.e. it can be modified art any time. We can remove characters, replace them, add others.

In Cocoa, mutable classes derive from immutable. This allows to cast NSMutableString down to NSString. This has a lot of advantages. For example every mutable string inherits all the properties of immutable. At the same time it leads to a lot of confusion. You need to constantly watch for these situations. Here is one such example:

What is wrong with the above code? We have created an immutable copy of str, and will be trying to append a string to it. Here is what will be printed to the console. Note that both mutable and immutable instances show as NSCFString class.

2008-10-10 20:12:57.943 XMLTests[1634:813] NSCFString:   123456
Current language:  auto; currently objective-c
2008-10-10 20:13:00.089 XMLTests[1634:813] NSCFString:   123456   789
2008-10-10 20:13:00.635 XMLTests[1634:813] *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: 'Attempt to mutate immutable object with appendString:'

For the complete reference of NSString and NSMutableString please refer to Apple’s documentation, particularly to the String Programming Guide for Cocoa.

Encodings

Similarly to many other languages, such as Java or C#, strings in Cocoa are implemented as arrays of Unicode characters. NSString objects can be converted to and from various other kinds of strings:

Here is the complete list of available encodings:

• Creating an NSString:

• Converting a string to a NULL-terminated character array:

I will show the basic set of functions that most of us would need to deal with on a daily basis, such as sorting and searching.

Example. Extracting image URLs from HTML stream.

In selection (2), we are extracting a substring of a given length from the original string.

Question: What would we do if we just wanted to get a single character at a given location?

Answer:

Other things we can do with NSString

• Replace all percent escapes from an XML/HTML string

• Compare two strings for equality - selection (1) below. Also, we could use this function:

• Trim whitespaces off the string - selection (2) below.

• String formatting

• Upper/Lower case conversions:

– capitalizedString
– lowercaseString
– uppercaseString

• Available number conversions

Example:
NSNumber *number = [NSNumber numberWithDouble:[str doubleValue]];
– doubleValue
– floatValue
– intValue
– integerValue
– longLongValue
– boolValue

• Date conversions
  • Not available on iPhone

• • Available on iPhone

Operations on NSMutableString-s

Once again, mutable strings are the ones that can be manipulated, for example, we can:

• Replace strings

• Delete characters

• Append strings

Standard C Library

Interoperability between C and Objective-C brings a lot of important advantages to Mac programming:

• <string.h> functions. This brings us an ability to use functions such as strstr, strtok, and more.

• <glob.h> functions. Simple, shell-expansion-like pattern matching

• <regex.h> functions. There are no regular expressions wrappers in Cocoa. Srtandard C Library regex facility is very efficient and convenient for more sophisticated string searching and replacement. A number of popular wrappers are available, such as CSRegex, but even such wrappers may be inefficient if a lot of parsing is required. Here is an example of using <regex.h> functions. Note that pattern is an actual regular expression (@”[0-9]+”) and string is the actual string (@”123456789”).

• regular C pointer arithmetics. In situations where it is necessary to iterate through a string character by character, using NSString may prove to be very expensive, especially in a constrained environment such as the iPhone

Example. Stripping images and iframes from HTML content.

Conclusions

The goal of this article was not to show you every function or class available, but rather to understand what is available, why, and where to find information if you need it. In addition to superb documentation that accompanies Xcode, there are tons of articles and examples available on the web, and a C library reference that can be found using the man command. And if you have more questions, please write to cocoacast@gmail.com.

Vladimir Pasman
Copyright 2008, Mesh Systems Inc.
donated to cocoacast.com
Friday, October 10, 2008