Kiedy używać enumerateObjectsUsingBlock, a kiedy for

Oprócz oczywistych różnic:

• Użyj, enumerateObjectsUsingBlockgdy potrzebujesz zarówno indeksu, jak i obiektu
• Nie używaj, enumerateObjectsUsingBlockgdy musisz zmodyfikować zmienne lokalne (myliłem się, zobacz odpowiedź bbum)

Czy enumerateObjectsUsingBlockogólnie uważa się, że lepiej czy gorzej, kiedy for (id obj in myArray)również zadziała? Jakie są zalety / wady (na przykład czy jest bardziej lub mniej wydajne)?

Ostatecznie użyj dowolnego wzoru, którego chcesz użyć i jest bardziej naturalny w kontekście.

Chociaż for(... in ...)jest dość wygodny i krótki składniowo, enumerateObjectsUsingBlock:ma wiele funkcji, które mogą okazać się interesujące lub nie:

• enumerateObjectsUsingBlock:będzie tak samo szybkie lub szybsze niż szybkie wyliczanie ( for(... in ...)używa NSFastEnumerationwsparcia do implementacji wyliczania). Szybkie wyliczanie wymaga tłumaczenia z reprezentacji wewnętrznej na reprezentację w celu szybkiego wyliczenia. Jest w tym nad głową. Wyliczanie oparte na blokach umożliwia klasie kolekcji wyliczanie zawartości tak szybko, jak najszybsze przechodzenie w rodzimym formacie magazynu. Prawdopodobnie nie ma to znaczenia w przypadku tablic, ale w przypadku słowników może to być ogromna różnica.

• „Nie używaj enumerateObjectsUsingBlock, gdy musisz zmodyfikować zmienne lokalne” - nie prawda; możesz zadeklarować swoje lokalne adresy jako __blocki będą dostępne do zapisu w bloku.

• enumerateObjectsWithOptions:usingBlock: obsługuje wyliczanie równoczesne lub odwrotne.

• W przypadku słowników wyliczanie oparte na blokach jest jedynym sposobem jednoczesnego pobrania klucza i wartości.

Osobiście używam enumerateObjectsUsingBlock:częściej niż for (... in ...), ale - znowu - osobistego wyboru.

W przypadku prostego wyliczania, po prostu użycie szybkiego wyliczania (tj. for…in…Pętli) jest bardziej idiomatyczną opcją. Metoda blokowa może być nieznacznie szybsza, ale w większości przypadków nie ma to większego znaczenia - niewiele programów jest związanych z procesorem, a nawet wtedy rzadko zdarza się, że sama pętla zamiast obliczeń wewnątrz będzie wąskim gardłem.

Prosta pętla również czyta wyraźniej. Oto schemat dwóch wersji:

for (id x in y){
}

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

Nawet jeśli dodasz zmienną do śledzenia indeksu, prosta pętla będzie łatwiejsza do odczytania.

Kiedy więc powinieneś użyć enumerateObjectsUsingBlock:? Kiedy przechowujesz blok do wykonania później lub w wielu miejscach. Jest to dobre rozwiązanie, gdy w rzeczywistości używasz bloku jako funkcji pierwszej klasy, a nie zastępczego zamiennika ciała pętli.

Chociaż to pytanie jest stare, nic się nie zmieniło, przyjęta odpowiedź jest nieprawidłowa.

enumerateObjectsUsingBlockAPI nie miało zastępują for-in, ale na zupełnie innym przypadku użycia:

• Pozwala na zastosowanie dowolnej, nielokalnej logiki. tj. nie musisz wiedzieć, co robi blok, aby użyć go na tablicy.
• Równoczesne wyliczanie dla dużych kolekcji lub ciężkich obliczeń (przy użyciu withOptions:parametru)

Fast Enumeration with for-injest nadal idiomatyczną metodą wyliczania kolekcji.

Fast Enumeration korzysta ze zwięzłości kodu, czytelności i dodatkowych optymalizacji, które sprawiają, że jest nienaturalnie szybki. Szybszy niż stara pętla for w C!

Szybki test stwierdza, że ​​w roku 2014 na iOS 7 enumerateObjectsUsingBlockjest konsekwentnie o 700% wolniejszy niż for-in (na podstawie 1 mm iteracji tablicy 100 elementów).

Czy wydajność jest tutaj praktycznym problemem?

Zdecydowanie nie, z rzadkimi wyjątkami.

Chodzi o to, aby wykazać, że istnieje niewiele korzyści przy użyciu enumerateObjectsUsingBlock:ponad for-inbez naprawdę dobrego powodu. Nie czyni kodu bardziej czytelnym ... ani szybszym ... ani bezpiecznym wątkowo. (kolejne powszechne nieporozumienie).

Wybór sprowadza się do osobistych preferencji. U mnie wygrywa opcja idiomatyczna i czytelna. W tym przypadku jest to szybkie wyliczanie przy użyciu for-in.

Reper:

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

Wyniki:

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

Aby odpowiedzieć na pytanie dotyczące wydajności, wykonałem kilka testów, korzystając z mojego projektu testów wydajności . Chciałem wiedzieć, która z trzech opcji wysyłania wiadomości do wszystkich obiektów w tablicy jest najszybsza.

Dostępne opcje to:

1) makeObjectsPerformSelector

[arr makeObjectsPerformSelector:@selector(_stubMethod)];

2) szybkie wyliczanie i regularne wysyłanie wiadomości

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

3) enumerateObjectsUsingBlock i zwykłe wysyłanie wiadomości

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

Okazuje się, że makeObjectsPerformSelector był zdecydowanie najwolniejszy. Zajęło to dwa razy więcej czasu niż szybkie wyliczenie. A enumerateObjectsUsingBlock był najszybszy, był około 15-20% szybszy niż szybka iteracja.

Więc jeśli bardzo martwisz się o najlepszą możliwą wydajność, użyj enumerateObjectsUsingBlock. Należy jednak pamiętać, że w niektórych przypadkach czas potrzebny do wyliczenia kolekcji skraca się o czas potrzebny do uruchomienia dowolnego kodu, który ma wykonać każdy obiekt.

Używanie enumerateObjectsUsingBlock jako zewnętrznej pętli jest dość przydatne, gdy chcesz przerwać zagnieżdżone pętle.

na przykład

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

Alternatywą jest użycie instrukcji goto.

Podziękowania dla @bbum i @Chuck za rozpoczęcie wszechstronnych porównań wydajności. Cieszę się, że to trywialne. Wydaje mi się, że poszedłem z:

• for (... in ...)- jako moje domyślne goto. Bardziej intuicyjny dla mnie, więcej historii programowania niż jakiekolwiek rzeczywiste preferencje - ponowne użycie w różnych językach, mniej pisania dla większości struktur danych dzięki automatycznemu uzupełnianiu IDE: P.

• enumerateObject...- kiedy potrzebny jest dostęp do obiektu i indeksu. Podczas uzyskiwania dostępu do struktur innych niż tablice lub słownikowe (osobiste preferencje)

• for (int i=idx; i<count; i++) - dla tablic, kiedy muszę zacząć od niezerowego indeksu