Best way to remove from NSMutableArray while iterating

When working with dynamic data structures in Objective-C, especially NSMutableArray, a common challenge arises when you need to modify the array while simultaneously iterating over its elements. Developers often encounter crashes or unexpected behavior, typically an NSRangeException or a “mutation during enumeration” error. This article delves into the intricacies of this problem, providing expert guidance on the best way to remove from NSMutableArray while iterating, ensuring your applications remain stable and performant. Understanding the correct techniques is crucial for robust iOS and macOS development, preventing hard-to-debug issues that stem from concurrent modification.

The Perils of Concurrent Modification in NSMutableArray

Attempting to remove objects from an NSMutableArray directly within a standard forward iteration loop, such as a for-in loop or a C-style for loop incrementing the index, almost invariably leads to runtime errors. This phenomenon is known as “mutation during enumeration.” When you remove an element, the array’s size changes, and the indices of subsequent elements shift. If your loop continues to increment an index that no longer corresponds to the original element or exceeds the new, smaller array bounds, a crash is imminent.

Consider a scenario where you’re iterating through a list of tasks and removing completed ones. If you remove an item at index i, the item previously at index i+1 now moves to index i. If your loop then increments to i+1, you will skip the element that just moved into index i. Worse, if you remove multiple items, the index can quickly go out of bounds, triggering an NSRangeException. This fundamental issue highlights why a direct approach is unsafe and ineffective for modifying collections during active enumeration.

The system enforces this safeguard to prevent unpredictable states and data corruption. As a developer, recognizing these concurrent modification pitfalls is the first step towards implementing safe and reliable array manipulation. The goal is always to ensure that the collection’s state is consistent throughout the modification process, avoiding index out of bounds errors and maintaining data integrity.

Safe and Effective Removal Strategies for NSMutableArray --------------------------------------------------------

Given the inherent dangers of direct concurrent modification, Objective-C developers have several proven strategies to safely remove objects from an NSMutableArray while iterating. The choice of method often depends on factors like the number of items to remove, performance considerations, and the complexity of the removal criteria. Each approach sidesteps the mutation during enumeration error by either changing the iteration direction, deferring the removal, or using a high-level filtering mechanism.

The best way to remove from NSMutableArray while iterating is not a one-size-fits-all answer but rather a selection based on context. These strategies are crucial for maintaining application stability and are considered best practices within the Cocoa development community. They ensure that operations on dynamic arrays are both efficient and error-free, preventing common crashes related to collection modification.

We’ll explore three primary methods: iterating backwards, collecting objects for removal in a temporary array, and leveraging NSPredicate for declarative filtering. Each method offers distinct advantages, making them suitable for different scenarios where elements need to be removed from a mutable array based on specific conditions.

Method 1: Iterating Backwards Through the Array

One of the most straightforward and commonly recommended techniques to remove objects from an NSMutableArray while iterating is to traverse the array in reverse order. This method elegantly bypasses the index shifting problem. When you iterate from the end of the array towards the beginning, removing an element at index i does not affect the indices of any elements that you still need to process (which are at indices 0 to i-1). This ensures that your loop’s index remains valid for the remaining elements, preventing index out of bounds exceptions.

For scenarios where you need to remove individual items based on a simple condition, iterating backwards is often considered the best way to remove from NSMutableArray while iterating due to its simplicity and efficiency. It avoids the overhead of creating new arrays or complex predicate evaluations, making it ideal for performance-sensitive tasks involving a relatively small number of removals. This technique is robust and widely adopted by experienced Objective-C developers.

To implement backward iteration effectively, you simply initialize your loop counter to [array count] - 1 and decrement it until it reaches 0. Inside the loop, you apply your removal condition, and if met, you remove the object at the current index. This approach ensures that the integrity of the iteration is maintained throughout the modification process.

Initialize a C-style for loop with an index starting from [array count] - 1.
Set the loop condition to continue as long as the index is greater than or equal to 0.
Decrement the index in each iteration (i--).
Inside the loop, apply your condition to the object at the current index.
If the condition is met, call [array removeObjectAtIndex:i].

Method 2: Collecting Objects for Removal (Two-Pass Approach)

Another robust and flexible strategy involves a two-pass approach: first identifying all objects that need to be removed, and then performing the actual removals in a separate step. This method is particularly useful when the removal criteria are complex, or when you prefer to use a standard forward iteration for identification. It guarantees that the collection is not mutated during the initial enumeration phase, thus avoiding enumeration mutation errors.

To implement this, you typically create a temporary NSMutableArray to store references to the objects slated for deletion. During your initial forward pass through the original array, if an object meets your removal criteria, you add it to this temporary “objects to delete” array. Once the first pass is complete, you then iterate through the temporary array and remove each identified object from the original array. This two-pass removal ensures complete safety, as the original array’s structure remains unchanged during the identification phase.

This method, while requiring slightly more memory for the temporary array, offers excellent readability and is highly adaptable for scenarios where the conditions for removal might involve properties or interactions that are easier to assess in a forward pass. It’s an excellent choice when the number of items to remove is potentially large, and mutable copy operations are acceptable for clarity and safety. For more advanced collection management tips, consider exploring efficient Objective-C data structures.

Pros:
- Allows for standard forward iteration during identification.
- Highly readable and easy to understand.
- Safer for complex conditional removals.
Question & Answer :
In Cocoa, if I want to loop through an NSMutableArray and remove multiple objects that fit a certain criteria, what’s the best way to do this without restarting the loop each time I remove an object?

Thanks,

Edit: Just to clarify - I was looking for the best way, e.g. something more elegant than manually updating the index I’m at. For example in C++ I can do;
```
iterator it = someList.begin(); while (it != someList.end()) { if (shouldRemove(it)) it = someList.erase(it); } 
```
For clarity I like to make an initial loop where I collect the items to delete. Then I delete them. Here’s a sample using Objective-C 2.0 syntax:
```
NSMutableArray *discardedItems = [NSMutableArray array]; for (SomeObjectClass *item in originalArrayOfItems) { if ([item shouldBeDiscarded]) [discardedItems addObject:item]; } [originalArrayOfItems removeObjectsInArray:discardedItems]; 
```
Then there is no question about whether indices are being updated correctly, or other little bookkeeping details.

Edited to add:

It’s been noted in other answers that the inverse formulation should be faster. i.e. If you iterate through the array and compose a new array of objects to keep, instead of objects to discard. That may be true (although what about the memory and processing cost of allocating a new array, and discarding the old one?) but even if it’s faster it may not be as big a deal as it would be for a naive implementation, because NSArrays do not behave like “normal” arrays. They talk the talk but they walk a different walk. See a good analysis here:

The inverse formulation may be faster, but I’ve never needed to care whether it is, because the above formulation has always been fast enough for my needs.

For me the take-home message is to use whatever formulation is clearest to you. Optimize only if necessary. I personally find the above formulation clearest, which is why I use it. But if the inverse formulation is clearer to you, go for it.