Quand utiliser enumerateObjectsUsingBlock ou pour

Outre les différences évidentes:

• À utiliser enumerateObjectsUsingBlocklorsque vous avez besoin à la fois de l'index et de l'objet
• Ne pas utiliser enumerateObjectsUsingBlocklorsque vous devez modifier des variables locales (je me suis trompé à ce sujet, voir la réponse de bbum)

Est-ce enumerateObjectsUsingBlockgénéralement considéré comme meilleur ou pire quand for (id obj in myArray)fonctionnerait également? Quels sont les avantages / inconvénients (par exemple est-il plus ou moins performant)?

En fin de compte, utilisez le modèle que vous souhaitez utiliser et qui vient plus naturellement dans le contexte.

Bien qu'il for(... in ...)soit assez pratique et syntaxiquement bref, il enumerateObjectsUsingBlock:présente un certain nombre de fonctionnalités qui peuvent ou non s'avérer intéressantes:

• enumerateObjectsUsingBlock:sera aussi rapide ou plus rapide que l'énumération rapide ( for(... in ...)utilise le NSFastEnumerationsupport pour implémenter l'énumération). L'énumération rapide nécessite la traduction d'une représentation interne vers la représentation pour une énumération rapide. Il y a des frais généraux là-dedans. L'énumération basée sur des blocs permet à la classe de collection d'énumérer le contenu aussi rapidement que le parcours le plus rapide du format de stockage natif. Probablement pas pertinent pour les tableaux, mais cela peut être une énorme différence pour les dictionnaires.

• "N'utilisez pas enumerateObjectsUsingBlock lorsque vous devez modifier des variables locales" - pas vrai; vous pouvez déclarer vos sections locales comme __blocket elles seront inscriptibles dans le bloc.

• enumerateObjectsWithOptions:usingBlock: prend en charge l'énumération simultanée ou inversée.

• avec les dictionnaires, l'énumération par blocs est le seul moyen de récupérer simultanément la clé et la valeur.

Personnellement, j'utilise enumerateObjectsUsingBlock:plus souvent que for (... in ...), mais - encore une fois - choix personnel.

Pour une énumération simple, utiliser simplement une énumération rapide (c'est-à-dire une for…in…boucle) est l'option la plus idiomatique. La méthode par blocs peut être légèrement plus rapide, mais cela n'a pas beaucoup d'importance dans la plupart des cas - peu de programmes sont liés au processeur, et même dans ce cas, il est rare que la boucle elle-même plutôt que le calcul à l'intérieur soit un goulot d'étranglement.

Une simple boucle se lit également plus clairement. Voici le passe-partout des deux versions:

for (id x in y){
}

[y enumerateObjectsUsingBlock:^(id x, NSUInteger index, BOOL *stop){
}];

Même si vous ajoutez une variable pour suivre l'index, la boucle simple est plus facile à lire.

Alors, quand devriez-vous utiliser enumerateObjectsUsingBlock:? Lorsque vous stockez un bloc à exécuter plus tard ou à plusieurs endroits. C'est bien lorsque vous utilisez réellement un bloc comme fonction de première classe plutôt que comme un remplacement surchargé d'un corps de boucle.

Bien que cette question soit ancienne, les choses n'ont pas changé, la réponse acceptée est incorrecte.

L' enumerateObjectsUsingBlockAPI n'était pas censée remplacer for-in, mais pour un cas d'utilisation totalement différent:

• Il permet l'application d'une logique arbitraire et non locale. c'est-à-dire que vous n'avez pas besoin de savoir ce que fait le bloc pour l'utiliser sur un tableau.
• Énumération simultanée pour les grandes collections ou les calculs lourds (à l'aide du withOptions:paramètre)

L'énumération rapide avec for-inest toujours la méthode idiomatique d'énumération d'une collection.

Fast Enumeration bénéficie de la brièveté du code, de la lisibilité et des optimisations supplémentaires qui le rendent anormalement rapide. Plus rapide qu'une ancienne boucle for C!

Un test rapide conclut qu'en 2014 sur iOS 7, il enumerateObjectsUsingBlockest systématiquement 700% plus lent que for-in (basé sur des itérations de 1 mm d'un tableau de 100 éléments).

La performance est-elle ici une réelle préoccupation pratique?

Certainement pas, à de rares exceptions près.

Le but est de démontrer qu'il y a peu d'avantages à utiliser enumerateObjectsUsingBlock:over for-insans une très bonne raison. Cela ne rend pas le code plus lisible ... ni plus rapide ... ni thread-safe. (une autre idée fausse courante).

Le choix se résume à une préférence personnelle. Pour moi, l'option idiomatique et lisible gagne. Dans ce cas, c'est l'énumération rapide utilisant for-in.

Référence:

NSMutableArray *arr = [NSMutableArray array];
for (int i = 0; i < 100; i++) {
    arr[i] = [NSString stringWithFormat:@"%d", i];
}
int i;
__block NSUInteger length;

i = 1000 * 1000;
uint64_t a1 = mach_absolute_time();
while (--i > 0) {
    for (NSString *s in arr) {
        length = s.length;
    }
}
NSLog(@"For-in %llu", mach_absolute_time()-a1);

i = 1000 * 1000;
uint64_t b1 = mach_absolute_time();
while (--i > 0) {
    [arr enumerateObjectsUsingBlock:^(NSString *s, NSUInteger idx, BOOL *stop) {
        length = s.length;
    }];
}
NSLog(@"Enum %llu", mach_absolute_time()-b1);

Résultats:

2014-06-11 14:37:47.717 Test[57483:60b] For-in 1087754062
2014-06-11 14:37:55.492 Test[57483:60b] Enum   7775447746

Pour répondre à la question sur les performances, j'ai fait quelques tests en utilisant mon projet de test de performance . Je voulais savoir laquelle des trois options pour envoyer un message à tous les objets d'un tableau est la plus rapide.

Les options étaient:

1) makeObjectsPerformSelector

[arr makeObjectsPerformSelector:@selector(_stubMethod)];

2) énumération rapide et envoi régulier de messages

for (id item in arr)
{
    [item _stubMethod];
}

3) enumerateObjectsUsingBlock et envoi régulier de messages

[arr enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) 
 {
     [obj _stubMethod];
 }];

Il s'avère que makeObjectsPerformSelector était de loin le plus lent. Il a fallu deux fois plus de temps que le dénombrement rapide. Et enumerateObjectsUsingBlock était le plus rapide, il était environ 15 à 20% plus rapide qu'une itération rapide.

Donc, si vous êtes très préoccupé par les meilleures performances possibles, utilisez enumerateObjectsUsingBlock. Mais gardez à l'esprit que dans certains cas, le temps nécessaire pour énumérer une collection est réduit par le temps nécessaire pour exécuter le code que vous souhaitez que chaque objet exécute.

Il est assez utile d'utiliser enumerateObjectsUsingBlock comme boucle externe lorsque vous souhaitez interrompre les boucles imbriquées.

par exemple

[array1 enumerateObjectsUsingBlock:^(id obj1, NSUInteger idx, BOOL * _Nonnull stop) {
  for(id obj2 in array2) {
    for(id obj3 in array3) {
      if(condition) {
        // break ALL the loops!
        *stop = YES;
        return;
      }
    }
  }
}];

L'alternative consiste à utiliser des instructions goto.

Merci à @bbum et @Chuck pour avoir lancé des comparaisons complètes sur les performances. Heureux de savoir que c'est trivial. Il me semble que je suis allé avec:

• for (... in ...)- par défaut goto. Plus intuitif pour moi, plus d'historique de programmation ici que n'importe quelle préférence réelle - réutilisation de plusieurs langages, moins de frappe pour la plupart des structures de données grâce à l'auto-complétion IDE: P.

• enumerateObject...- lorsque l'accès à l'objet et à l'index est nécessaire. Et lors de l'accès à des structures non-tableau ou dictionnaire (préférence personnelle)

• for (int i=idx; i<count; i++) - pour les tableaux, quand j'ai besoin de démarrer sur un index non nul