How do I iterate over an NSArray?

The generally-preferred code for 10.5+/iOS.

for (id object in array) {    // do something with object}

This construct is used to enumerate objects in a collection which conforms to the NSFastEnumeration protocol. This approach has a speed advantage because it stores pointers to several objects (obtained via a single method call) in a buffer and iterates through them by advancing through the buffer using pointer arithmetic. This is much faster than calling -objectAtIndex: each time through the loop.

It's also worth noting that while you technically can use a for-in loop to step through an NSEnumerator, I have found that this nullifies virtually all of the speed advantage of fast enumeration. The reason is that the default NSEnumerator implementation of -countByEnumeratingWithState:objects:count: places only one object in the buffer on each call.

I reported this in radar://6296108 (Fast enumeration of NSEnumerators is sluggish) but it was returned as Not To Be Fixed. The reason is that fast enumeration pre-fetches a group of objects, and if you want to enumerate only to a given point in the enumerator (e.g. until a particular object is found, or condition is met) and use the same enumerator after breaking out of the loop, it would often be the case that several objects would be skipped.

If you are coding for OS X 10.6 / iOS 4.0 and above, you also have the option of using block-based APIs to enumerate arrays and other collections:

[array enumerateObjectsUsingBlock:^(id object, NSUInteger idx, BOOL *stop) {    // do something with object}];

You can also use -enumerateObjectsWithOptions:usingBlock: and pass NSEnumerationConcurrent and/or NSEnumerationReverse as the options argument.

10.4 or earlier

The standard idiom for pre-10.5 is to use an NSEnumerator and a while loop, like so:

NSEnumerator *e = [array objectEnumerator];id object;while (object = [e nextObject]) {  // do something with object}

I recommend keeping it simple. Tying yourself to an array type is inflexible, and the purported speed increase of using -objectAtIndex: is insignificant to the improvement with fast enumeration on 10.5+ anyway. (Fast enumeration actually uses pointer arithmetic on the underlying data structure, and removes most of the method call overhead.) Premature optimization is never a good idea — it results in messier code to solve a problem that isn't your bottleneck anyway.

When using -objectEnumerator, you very easily change to another enumerable collection (like an NSSet, keys in an NSDictionary, etc.), or even switch to -reverseObjectEnumerator to enumerate an array backwards, all with no other code changes. If the iteration code is in a method, you could even pass in any NSEnumerator and the code doesn't even have to care about what it's iterating. Further, an NSEnumerator (at least those provided by Apple code) retains the collection it's enumerating as long as there are more objects, so you don't have to worry about how long an autoreleased object will exist.

Perhaps the biggest thing an NSEnumerator (or fast enumeration) protects you from is having a mutable collection (array or otherwise) change underneath you without your knowledge while you're enumerating it. If you access the objects by index, you can run into strange exceptions or off-by-one errors (often long after the problem has occurred) that can be horrific to debug. Enumeration using one of the standard idioms has a "fail-fast" behavior, so the problem (caused by incorrect code) will manifest itself immediately when you try to access the next object after the mutation has occurred. As programs get more complex and multi-threaded, or even depend on something that third-party code may modify, fragile enumeration code becomes increasingly problematic. Encapsulation and abstraction FTW! :-)

For OS X 10.4.x and previous:

 int i; for (i = 0; i < [myArray count]; i++) {   id myArrayElement = [myArray objectAtIndex:i];   ...do something useful with myArrayElement }

For OS X 10.5.x (or iPhone) and beyond:

for (id myArrayElement in myArray) {   ...do something useful with myArrayElement}

The results of the test and source code are below (you can set the number of iterations in the app). The time is in milliseconds, and each entry is an average result of running the test 5-10 times. I found that generally it is accurate to 2-3 significant digits and after that it would vary with each run. That gives a margin of error of less than 1%. The test was running on an iPhone 3G as that's the target platform I was interested in.

numberOfItems   NSArray (ms)    C Array (ms)    Ratio100             0.39            0.0025          156191             0.61            0.0028          2183,256           12.5            0.026           4814,789           16              0.037           4326,794           21              0.050           42010,919          36              0.081           44419,731          64              0.15            42722,030          75              0.162           46332,758          109             0.24            45477,969          258             0.57            453100,000         390             0.73            534

The classes provided by Cocoa for handling data sets (NSDictionary, NSArray, NSSet etc.) provide a very nice interface for managing information, without having to worry about the bureaucracy of memory management, reallocation etc. Of course this does come at a cost though. I think it's pretty obvious that say using an NSArray of NSNumbers is going to be slower than a C Array of floats for simple iterations, so I decided to do some tests, and the results were pretty shocking! I wasn't expecting it to be this bad. Note: these tests are conducted on an iPhone 3G as that's the target platform I was interested in.

In this test I do a very simple random access performance comparison between a C float* and NSArray of NSNumbers

I create a simple loop to sum up the contents of each array and time them using mach_absolute_time(). The NSMutableArray takes on average 400 times longer!! (not 400 percent, just 400 times longer! thats 40,000% longer!).

Header:

// Array_Speed_TestViewController.h

// Array Speed Test

// Created by Mehmet Akten on 05/02/2009.

// Copyright MSA Visuals Ltd. 2009. All rights reserved.

#import <UIKit/UIKit.h>@interface Array_Speed_TestViewController : UIViewController {    int                     numberOfItems;          // number of items in array    float                   *cArray;                // normal c array    NSMutableArray          *nsArray;               // ns array    double                  machTimerMillisMult;    // multiplier to convert mach_absolute_time() to milliseconds    IBOutlet    UISlider    *sliderCount;    IBOutlet    UILabel     *labelCount;    IBOutlet    UILabel     *labelResults;}-(IBAction) doNSArray:(id)sender;-(IBAction) doCArray:(id)sender;-(IBAction) sliderChanged:(id)sender;@end

Implementation:

// Array_Speed_TestViewController.m

// Array Speed Test

// Created by Mehmet Akten on 05/02/2009.

// Copyright MSA Visuals Ltd. 2009. All rights reserved.

    #import "Array_Speed_TestViewController.h"    #include <mach/mach.h>    #include <mach/mach_time.h> @implementation Array_Speed_TestViewController // Implement viewDidLoad to do additional setup after loading the view, typically from a nib.- (void)viewDidLoad {    NSLog(@"viewDidLoad");    [super viewDidLoad];    cArray      = NULL;    nsArray     = NULL;    // read initial slider value setup accordingly    [self sliderChanged:sliderCount];    // get mach timer unit size and calculater millisecond factor    mach_timebase_info_data_t info;    mach_timebase_info(&info);    machTimerMillisMult = (double)info.numer / ((double)info.denom * 1000000.0);    NSLog(@"machTimerMillisMult = %f", machTimerMillisMult);}// pass in results of mach_absolute_time()// this converts to milliseconds and outputs to the label-(void)displayResult:(uint64_t)duration {    double millis = duration * machTimerMillisMult;    NSLog(@"displayResult: %f milliseconds", millis);    NSString *str = [[NSString alloc] initWithFormat:@"%f milliseconds", millis];    [labelResults setText:str];    [str release];}// process using NSArray-(IBAction) doNSArray:(id)sender {    NSLog(@"doNSArray: %@", sender);    uint64_t startTime = mach_absolute_time();    float total = 0;    for(int i=0; i<numberOfItems; i++) {        total += [[nsArray objectAtIndex:i] floatValue];    }    [self displayResult:mach_absolute_time() - startTime];}// process using C Array-(IBAction) doCArray:(id)sender {    NSLog(@"doCArray: %@", sender);    uint64_t start = mach_absolute_time();    float total = 0;    for(int i=0; i<numberOfItems; i++) {        total += cArray[i];    }    [self displayResult:mach_absolute_time() - start];}// allocate NSArray and C Array -(void) allocateArrays {    NSLog(@"allocateArrays");    // allocate c array    if(cArray) delete cArray;    cArray = new float[numberOfItems];    // allocate NSArray    [nsArray release];    nsArray = [[NSMutableArray alloc] initWithCapacity:numberOfItems];    // fill with random values    for(int i=0; i<numberOfItems; i++) {        // add number to c array        cArray[i] = random() * 1.0f/(RAND_MAX+1);        // add number to NSArray        NSNumber *number = [[NSNumber alloc] initWithFloat:cArray[i]];        [nsArray addObject:number];        [number release];    }}// callback for when slider is changed-(IBAction) sliderChanged:(id)sender {    numberOfItems = sliderCount.value;    NSLog(@"sliderChanged: %@, %i", sender, numberOfItems);    NSString *str = [[NSString alloc] initWithFormat:@"%i items", numberOfItems];    [labelCount setText:str];    [str release];    [self allocateArrays];}//cleanup- (void)dealloc {    [nsArray release];    if(cArray) delete cArray;    [super dealloc];}@end

From : memo.tv

////////////////////

Available since the introduction of blocks, this allows to iterate an array with blocks. Its syntax isn't as nice as fast enumeration, but there is one very interesting feature: concurrent enumeration. If enumeration order is not important and the jobs can be done in parallel without locking, this can provide a considerable speedup on a multi-core system. More about that in the concurrent enumeration section.

[myArray enumerateObjectsUsingBlock:^(id object, NSUInteger index, BOOL *stop) {    [self doSomethingWith:object];}];[myArray enumerateObjectsWithOptions:NSEnumerationConcurrent usingBlock:^(id obj, NSUInteger idx, BOOL *stop) {    [self doSomethingWith:object];}];

///////////NSFastEnumerator

The idea behind fast enumeration is to use fast C array access to optimize iteration. Not only is it supposed to be faster than traditional NSEnumerator, but Objective-C 2.0 also provides a very concise syntax.

id object;for (object in myArray) {    [self doSomethingWith:object];}

/////////////////

NSEnumerator

This is a form of external iteration: [myArray objectEnumerator] returns an object. This object has a method nextObject that we can call in a loop until it returns nil

NSEnumerator *enumerator = [myArray objectEnumerator];id object;while (object = [enumerator nextObject]) {    [self doSomethingWith:object];}

/////////////////

objectAtIndex: enumeration

Using a for loop which increases an integer and querying the object using [myArray objectAtIndex:index] is the most basic form of enumeration.

NSUInteger count = [myArray count];for (NSUInteger index = 0; index < count ; index++) {    [self doSomethingWith:[myArray objectAtIndex:index]];}

//////////////From : darkdust.net