Когда использовать enumerateObjectsUsingBlock по сравнению с for

В конечном счете, используйте любой шаблон, который вы хотите использовать, и он более естественен в контексте.

В то время как for(... in ...) довольно удобен и синтаксически краток, enumerateObjectsUsingBlock: имеет ряд особенностей, которые могут оказаться интересными, а могут и не оказаться:

• enumerateObjectsUsingBlock: будет таким же быстрым или даже быстрее, чем быстрое перечисление (for(... in ...) использует поддержку NSFastEnumeration для реализации перечисления). Быстрое перечисление требует перевода из внутреннего представления в представление для быстрого перечисления. Там есть накладные расходы. Перечисление на основе блоков позволяет классу коллекции перечислять содержимое так же быстро, как и самый быстрый обход собственного формата хранения. Вероятно, это не имеет значения для массивов, но может иметь огромное значение для словарей.

• «Не используйте enumerateObjectsUsingBlock, когда вам нужно изменить локальные переменные» — неверно; вы можете объявить своих местных жителей как __block, и они будут доступны для записи в блоке.

• enumerateObjectsWithOptions:usingBlock: поддерживает параллельное или обратное перечисление.

• со словарями перечисление на основе блоков является единственным способом одновременного извлечения ключа и значения.

Лично я использую enumerateObjectsUsingBlock: чаще, чем for (... in ...), но - опять же - личный выбор.

Для простого перечисления простое использование быстрого перечисления (т.е. цикл for…in…) является более идиоматичным вариантом. Блочный метод может быть немного быстрее, но в большинстве случаев это не имеет большого значения — немногие программы привязаны к процессору, и даже в этом случае узким местом будет сам цикл, а не вычисление внутри.

Простой цикл также читается более четко. Вот шаблон двух версий:

for (id x in y){
}

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

Даже если вы добавите переменную для отслеживания индекса, простой цикл будет легче читать.

Итак, когда вы должны использовать enumerateObjectsUsingBlock:? Когда вы сохраняете блок для выполнения позже или в нескольких местах. Это хорошо, когда вы на самом деле используете блок как первоклассную функцию, а не перегруженную замену тела цикла.

Хотя этот вопрос старый, ничего не изменилось, принятый ответ неверен

enumerateObjectsUsingBlock API не предназначался для замены for-in, но для совершенно другого варианта использования:

• Это позволяет применять произвольную нелокальную логику. то есть вам не нужно знать, что делает блок, чтобы использовать его в массиве.
• Параллельное перечисление для больших коллекций или тяжелых вычислений (с использованием параметра withOptions:)

Быстрое перечисление с for-in по-прежнему является идиоматическим методом перечисления коллекции.

Быстрое перечисление выигрывает от краткости кода, удобочитаемости и дополнительных оптимизаций, которые делают его неестественно быстрым. Быстрее, чем старый цикл for C!

Быстрый тест показывает, что в 2014 году на iOS 7 enumerateObjectsUsingBlock стабильно на 700 % медленнее, чем for-in (на основе 1 мм итераций массива из 100 элементов).

Является ли здесь производительность реальной практической проблемой?

Точно нет, за редким исключением.

Смысл в том, чтобы продемонстрировать, что использование enumerateObjectsUsingBlock: вместо for-in без действительно веской причины малоэффективно. Это не делает код более читабельным... или быстрым... или потокобезопасным. (еще одно распространенное заблуждение).

Выбор зависит от личных предпочтений. Для меня выигрывает идиоматический и читабельный вариант. В данном случае это быстрое перечисление с использованием for-in.

Ориентир:

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

Результаты:

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

Чтобы ответить на вопрос о производительности, я провел несколько тестов, используя мой проект тестирования производительности< /а>. Я хотел узнать, какой из трех вариантов отправки сообщения всем объектам в массиве самый быстрый.

[arr makeObjectsPerformSelector:@selector(_stubMethod)];

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

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

Довольно полезно использовать enumerateObjectsUsingBlock в качестве внешнего цикла, когда вы хотите разорвать вложенные циклы.

e.g.

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

Альтернативой является использование операторов goto.

Спасибо @bbum и @Chuck за всестороннее сравнение производительности. Рад узнать, что это банально. Кажется, я пошел с:

• for (... in ...) - мой путь по умолчанию. Для меня более интуитивно понятен, здесь больше истории программирования, чем любые реальные предпочтения - повторное использование на разных языках, меньше ввода для большинства структур данных из-за автоматического завершения IDE: P.

• enumerateObject... - когда нужен доступ к объекту и индексу. И при доступе к структурам, не являющимся массивами или словарями (личные предпочтения)

• for (int i=idx; i<count; i++) - для массивов, когда мне нужно начать с ненулевого индекса