Objective-C Fundamentals

Dictionaries
87
Because a dictionary is made up of key/value pairs, NSDictionary provides two
convenient messages to obtain enumerators to iterate over each entry in the dictionary.
The keyEnumerator message provides an enumerator that iterates over all keys in
the dictionary, while objectEnumerator performs a similar task but iterates over all
the values instead:
NSEnumerator *enumerator = [myDetails keyEnumerator];
id key;
while (key = [enumerator nextObject]) {
NSLog(@"Entry has key: %@", key);
}
Using the keyEnumerator message, this code snippet lists the name of each key currently
stored in the dictionary. Try using the objectEnumerator message on the first
line, and you’ll see the values listed instead. Fast enumeration is also possible, and if
you use the dictionary object directly, it iterates over all of the keys:
for (id key in myDetails) {
id value = [myDetails objectForKey:key];
}
NSLog(@"Entry with key '%@' has value '%@'", key, value);
This code sample also demonstrates that in the iteration loop it’s possible to use
objectForKey: to obtain the value that matches the current key. When placing code
in an enumeration loop, such as the one just shown, you must be careful that you
don’t mutate the data structure. As an example, you may think that one way to remove
all the entries in a dictionary (other than the more logical removeAllObjects) would
be the following code snippet:
for (id key in dictionary) {
[dictionary removeObjectForKey:key];
}
Although this appears conceptually correct, the code snippet has a fundamental flaw
that will result in an exception similar to the following and crash the application:
*** Terminating app due to uncaught exception 'NSGenericException', reason:
'*** Collection was mutated while being
enumerated.'
If you enumerate over a data structure by using fast enumeration or an NSEnumerator,
your code shouldn’t modify the associated data structure until your enumeration has
completed. Modifying the contents of an array or dictionary that’s currently being
enumerated will alter its internal data structure and cause any associated enumerators
to become invalid. If you need to enumerate through a dictionary and potentially add
or remove entries before enumeration has completed, you should first make a copy of
all the keys by calling a method such as allKeys. This method creates an array and
copies a list of all keys currently in the dictionary into that array. This allows you to