Objective-C enumerateObjectsUsingBlock vs énumération rapide ?

Question

Quels sont les avantages et les inconvénients des deux approches suivantes :

énumérer en utilisant le bloc

NSArray *myArray = [NSArray new];
[myArray enumerateObjectsUsingBlock:^(id anObject, NSUInteger idx, BOOL *stop) {
    if (anObject == someOtherObject) {
        [anObject doSomething:idx];
        *stop = YES;
    }
}];

énumération rapide

NSArray *myArray = [NSArray new];
int idx = 0
for (id anObject in myArray) {
    if (anObject == someOtherObject) {
        [anObject doSomething:idx];
        break;
    }
    ++idx;
}

Answer 1

Cet article de blog couvre les principales différences. En résumé :

• L'énumération rapide est disponible sur OS X 10.5+, les blocs sont disponibles sur 10.6+.
• Pour une énumération simple, l'énumération rapide est un peu plus rapide que l'énumération par blocs.
• Il est plus facile (et plus performant) de faire une énumération simultanée ou inversée avec une énumération par blocs qu'avec une énumération rapide.
• Lors de l'énumération d'un NSDictionary vous pouvez obtenir la clé et la valeur en une seule fois avec un énumérateur basé sur des blocs, alors qu'avec une énumération rapide, vous devez utiliser la clé pour récupérer la valeur dans un message séparé.

En ce qui concerne le dernier point (énumération NSDictionary), comparez ceci :

for (id key in dictionary)
{
    id obj = [dictionary objectForKey: key];
    // do something with key and obj
}

à ça :

[dictionary enumerateKeysAndObjectsUsingBlock: ^(id key, id obj, BOOL *stop) {
    // do something with key and obj
}];

En outre, les deux méthodes protègent les collections mutables contre les mutations à l'intérieur de la boucle d'énumération. Il est intéressant de noter que si vous essayez de modifier la collection à l'intérieur d'une énumération basée sur des blocs, vous obtenez une exception lancée par la méthode de CoreFoundation __NSFastEnumerationMutationHandler ce qui suggère qu'il y a un code commun sous le capot.

 NSMutableArray *myArray = [NSMutableArray arrayWithObjects:@"a", @"b", nil];
 [myArray enumerateObjectsUsingBlock:^(id anObject, NSUInteger idx, BOOL *stop) {
     // Attempt to mutate the array during enumeration
     [myArray addObject:@"c"];
 }];

Sortie :

2011-12-14 22:37:53.716 Untitled[5809:707] *** Terminating app due to uncaught exception 'NSGenericException', reason: '*** Collection <__NSArrayM: 0x109614190> was mutated while being enumerated.'
*** First throw call stack:
(
    0   CoreFoundation                      0x00007fff8cca7286 __exceptionPreprocess + 198
    1   libobjc.A.dylib                     0x00007fff8319ad5e objc_exception_throw + 43
    2   CoreFoundation                      0x00007fff8cd311dc __NSFastEnumerationMutationHandler + 172
    3   CoreFoundation                      0x00007fff8cc9efb4 __NSArrayEnumerate + 612
    4   Untitled                            0x00000001094efcea main + 250
    5   Untitled                            0x00000001094efbe4 start + 52
    6   ???                                 0x0000000000000001 0x0 + 1
)
terminate called throwing an exceptionRun Command: line 1:  5809 Abort trap: 6           ./"$2"

Answer 2

Les premières pensées qui me viennent à l'esprit

• Les blocs sont disponibles à partir d'iOS 4. Si vous devez prendre en charge des versions antérieures, vous ne pouvez pas utiliser la syntaxe des blocs.

• Ils sont assez équivalents en termes de ce qu'ils font, sauf que vous ne pouvez pas accidentellement rater le compteur dans la version bloc.

• Une autre différence potentielle est que vous pouvez définir le bloc ailleurs et passer dans différents blocs en fonction de votre état.

J'espère que ce n'était qu'un exemple très approximatif car le code est assez pauvre et il existe des moyens plus efficaces de le faire ;)