Wann soll enumerateObjectsUsingBlock vs. für verwendet werden?

Neben den offensichtlichen Unterschieden:

• Verwenden enumerateObjectsUsingBlockSie diese Option, wenn Sie sowohl den Index als auch das Objekt benötigen
• Nicht verwenden, enumerateObjectsUsingBlockwenn Sie lokale Variablen ändern müssen (ich habe mich geirrt, siehe bbums Antwort)

Wird enumerateObjectsUsingBlockallgemein als besser oder schlechter angesehen, wann for (id obj in myArray)auch funktionieren würde? Was sind die Vor- und Nachteile (zum Beispiel ist es mehr oder weniger performant)?

Verwenden Sie letztendlich das Muster, das Sie verwenden möchten, und kommen Sie im Kontext natürlicher vor.

Obwohl for(... in ...)es recht praktisch und syntaktisch kurz ist, enumerateObjectsUsingBlock:hat es eine Reihe von Funktionen, die sich als interessant erweisen können oder nicht:

• enumerateObjectsUsingBlock:wird genauso schnell oder schneller sein als die schnelle Aufzählung ( for(... in ...)verwendet die NSFastEnumerationUnterstützung, um die Aufzählung zu implementieren). Eine schnelle Aufzählung erfordert eine Übersetzung von einer internen Darstellung in die Darstellung für eine schnelle Aufzählung. Es gibt Overhead darin. Durch die blockbasierte Aufzählung kann die Auflistungsklasse Inhalte so schnell auflisten wie die schnellste Durchquerung des nativen Speicherformats. Wahrscheinlich irrelevant für Arrays, aber für Wörterbücher kann es ein großer Unterschied sein.

• "Verwenden Sie enumerateObjectsUsingBlock nicht, wenn Sie lokale Variablen ändern müssen" - nicht wahr; Sie können Ihre Einheimischen als deklarieren __blockund sie werden im Block beschreibbar sein.

• enumerateObjectsWithOptions:usingBlock: unterstützt entweder gleichzeitige oder umgekehrte Aufzählung.

• Bei Wörterbüchern ist die blockbasierte Aufzählung die einzige Möglichkeit, Schlüssel und Wert gleichzeitig abzurufen.

Persönlich benutze ich enumerateObjectsUsingBlock:öfter als for (... in ...), aber - wieder - persönliche Wahl.

Für eine einfache Aufzählung ist die einfache Verwendung einer schnellen Aufzählung (dh einer for…in…Schleife) die idiomatischere Option. Die Blockmethode mag geringfügig schneller sein, aber das spielt in den meisten Fällen keine große Rolle - nur wenige Programme sind CPU-gebunden, und selbst dann ist es selten, dass die Schleife selbst und nicht die Berechnung im Inneren ein Engpass ist.

Eine einfache Schleife liest auch deutlicher. Hier ist das Boilerplate der beiden Versionen:

for (id x in y){
}

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

Selbst wenn Sie eine Variable hinzufügen, um den Index zu verfolgen, ist die einfache Schleife leichter zu lesen.

Also wann solltest du verwenden enumerateObjectsUsingBlock:? Wenn Sie einen Block speichern, um ihn später oder an mehreren Stellen auszuführen. Dies ist gut, wenn Sie einen Block tatsächlich als erstklassige Funktion verwenden und nicht als überarbeiteten Ersatz für einen Schleifenkörper.

Obwohl diese Frage alt ist, haben sich die Dinge nicht geändert, die die akzeptierte Antwort ist falsch.

Die enumerateObjectsUsingBlockAPI sollte nicht ersetzen for-in, sondern für einen völlig anderen Anwendungsfall:

• Es ermöglicht die Anwendung beliebiger, nicht lokaler Logik. Das heißt, Sie müssen nicht wissen, was der Block tut, um ihn in einem Array zu verwenden.
• Gleichzeitige Aufzählung für große Sammlungen oder umfangreiche Berechnungen (unter Verwendung des withOptions:Parameters)

Schnelle Aufzählung mit for-inist immer noch die idiomatische Methode zum Auflisten einer Sammlung.

Die schnelle Aufzählung profitiert von der Kürze des Codes, der Lesbarkeit und zusätzlichen Optimierungen , die ihn unnatürlich schnell machen. Schneller als eine alte C-for-Schleife!

Ein schneller Test kommt zu dem Schluss, dass das Jahr 2014 unter iOS 7 enumerateObjectsUsingBlockdurchweg 700% langsamer ist als das For-In (basierend auf 1-mm-Iterationen eines 100-Elemente-Arrays).

Ist Leistung hier ein echtes praktisches Anliegen?

Auf keinen Fall, mit seltenen Ausnahmen.

Der Punkt ist zu zeigen, dass die Verwendung von enumerateObjectsUsingBlock:Over for-inohne wirklich guten Grund wenig Nutzen bringt. Es macht den Code nicht lesbarer ... oder schneller ... oder threadsicherer. (ein weiteres häufiges Missverständnis).

Die Wahl hängt von den persönlichen Vorlieben ab. Für mich gewinnt die idiomatische und lesbare Option. In diesem Fall ist dies die schnelle Aufzählung mit for-in.

Benchmark:

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);

Ergebnisse:

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

Um die Frage nach der Leistung zu beantworten, habe ich einige Tests mit meinem Leistungstestprojekt durchgeführt . Ich wollte wissen, welche der drei Optionen zum Senden einer Nachricht an alle Objekte in einem Array die schnellste ist.

Die Optionen waren:

1) makeObjectsPerformSelector

[arr makeObjectsPerformSelector:@selector(_stubMethod)];

2) schnelle Aufzählung und reguläres Senden von Nachrichten

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

3) enumerateObjectsUsingBlock & reguläres Senden von Nachrichten

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

Es stellt sich heraus, dass makeObjectsPerformSelector bei weitem am langsamsten war. Die schnelle Aufzählung dauerte doppelt so lange. Und enumerateObjectsUsingBlock war am schnellsten, es war ungefähr 15-20% schneller als schnelle Iteration.

Wenn Sie sich also große Sorgen um die bestmögliche Leistung machen, verwenden Sie enumerateObjectsUsingBlock. Beachten Sie jedoch, dass in einigen Fällen die Zeit, die zum Auflisten einer Sammlung benötigt wird, durch die Zeit, die zum Ausführen des Codes benötigt wird, den jedes Objekt ausführen soll, in den Schatten gestellt wird.

Es ist ziemlich nützlich, enumerateObjectsUsingBlock als äußere Schleife zu verwenden, wenn Sie verschachtelte Schleifen unterbrechen möchten.

z.B

[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;
      }
    }
  }
}];

Die Alternative ist die Verwendung von goto-Anweisungen.

Vielen Dank an @bbum und @Chuck für den Start umfassender Leistungsvergleiche. Ich bin froh zu wissen, dass es trivial ist. Ich scheine gegangen zu sein mit:

• for (... in ...)- als meine Standardeinstellung. Intuitiver für mich, mehr Programmierverlauf als jede echte Präferenz - sprachübergreifende Wiederverwendung, weniger Eingabe für die meisten Datenstrukturen aufgrund der automatischen Vervollständigung der IDE: P.

• enumerateObject...- wenn Zugriff auf Objekt und Index benötigt wird. Und beim Zugriff auf Nicht-Array- oder Wörterbuchstrukturen (persönliche Präferenz)

• for (int i=idx; i<count; i++) - für Arrays, wenn ich mit einem Index ungleich Null beginnen muss