Quando usar enumerateObjectsUsingBlock vs. for

Além das diferenças óbvias:

• Use enumerateObjectsUsingBlockquando você precisar do índice e do objeto
• Não use enumerateObjectsUsingBlockquando precisar modificar variáveis ​​locais (eu estava errado sobre isso, veja a resposta do bbum)

enumerateObjectsUsingBlockGeralmente é considerado melhor ou pior quando for (id obj in myArray)também funcionaria? Quais são as vantagens / desvantagens (por exemplo, é mais ou menos desempenho)?

Por fim, use o padrão que você deseja usar e seja mais natural no contexto.

Embora for(... in ...)seja bastante conveniente e sintaticamente breve, enumerateObjectsUsingBlock:possui vários recursos que podem ou não ser interessantes:

• enumerateObjectsUsingBlock:será tão rápido ou mais rápido que a enumeração rápida ( for(... in ...)usa o NSFastEnumerationsuporte para implementar a enumeração). A enumeração rápida requer tradução de uma representação interna para a representação para enumeração rápida. Há sobrecarga nele. A enumeração baseada em bloco permite que a classe de coleção enumere o conteúdo tão rapidamente quanto a travessia mais rápida do formato de armazenamento nativo. Provavelmente irrelevante para matrizes, mas pode ser uma enorme diferença para dicionários.

• "Não use enumerateObjectsUsingBlock quando precisar modificar variáveis ​​locais" - não é verdade; você pode declarar seus locais como __blocke eles serão graváveis ​​no bloco.

• enumerateObjectsWithOptions:usingBlock: suporta enumeração simultânea ou reversa.

• com dicionários, a enumeração baseada em bloco é a única maneira de recuperar a chave e o valor simultaneamente.

Pessoalmente, uso com enumerateObjectsUsingBlock:mais frequência do que for (... in ...), mas - novamente - escolha pessoal.

Para enumeração simples, basta usar a enumeração rápida (ou seja, um for…in… loop) é a opção mais idiomática. O método de bloco pode ser um pouco mais rápido, mas isso não importa muito na maioria dos casos - poucos programas são vinculados à CPU e, mesmo assim, é raro que o próprio loop em vez da computação interna seja um gargalo.

Um loop simples também lê com mais clareza. Aqui está o boilerplate das duas versões:

for (id x in y){
}

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

Mesmo se você adicionar uma variável para rastrear o índice, o loop simples será mais fácil de ler.

Então, quando você deve usar enumerateObjectsUsingBlock:? Quando você está armazenando um bloco para executar mais tarde ou em vários lugares. É bom para quando você está realmente usando um bloco como uma função de primeira classe, em vez de uma substituição exagerada de um corpo de loop.

Embora essa pergunta seja antiga, as coisas não mudaram, a resposta aceita está incorreta.

A enumerateObjectsUsingBlockAPI não foi substituída for-in, mas para um caso de uso totalmente diferente:

• Permite a aplicação de lógica arbitrária e não local. ou seja, você não precisa saber o que o bloco faz para usá-lo em uma matriz.
• Enumeração simultânea para coleções grandes ou computação pesada (usando o withOptions:parâmetro)

A Enumeração Rápida com for-inainda é o método idiomático de enumerar uma coleção.

A Enumeração Rápida se beneficia da brevidade do código, da legibilidade e das otimizações adicionais, que a tornam estranhamente rápida. Mais rápido que um loop for C antigo!

Um teste rápido conclui que no ano de 2014 no iOS 7, enumerateObjectsUsingBlocké consistentemente 700% mais lento que o for-in (com base nas iterações de 1 mm de uma matriz de 100 itens).

O desempenho é uma preocupação prática real aqui?

Definitivamente não, com raras exceções.

O objetivo é demonstrar que há pouco benefício em usar enumerateObjectsUsingBlock:mais defor-in sem uma boa razão. Não torna o código mais legível ... ou mais rápido ... ou seguro para threads. (outro equívoco comum).

A escolha se resume à preferência pessoal. Para mim, a opção idiomática e legível vence. Nesse caso, isso é enumeração rápida usando for-in.

Referência:

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

Resultados:

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

Para responder à pergunta sobre desempenho, fiz alguns testes usando meu projeto de teste de desempenho . Eu queria saber qual das três opções para enviar uma mensagem para todos os objetos em uma matriz é a mais rápida.

As opções foram:

1) makeObjectsPerformSelector

[arr makeObjectsPerformSelector:@selector(_stubMethod)];

2) enumeração rápida e envio regular de mensagens

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

3) enumerateObjectsUsingBlock e envio regular de mensagens

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

Acontece que makeObjectsPerformSelector foi o mais lento de longe. Demorou o dobro do tempo da enumeração rápida. E o enumerateObjectsUsingBlock foi o mais rápido, cerca de 15 a 20% mais rápido que a iteração rápida.

Portanto, se você estiver muito preocupado com o melhor desempenho possível, use enumerateObjectsUsingBlock. Mas lembre-se de que, em alguns casos, o tempo que leva para enumerar uma coleção é diminuído pelo tempo que leva para executar o código que você deseja que cada objeto execute.

É bastante útil usar enumerateObjectsUsingBlock como um loop externo quando você deseja interromper loops aninhados.

por exemplo

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

A alternativa é usar instruções goto.

Agradecemos a @bbum e @Chuck por iniciarem comparações abrangentes sobre desempenho. Fico feliz em saber que é trivial. Eu pareço ter ido com:

• for (... in ...)- como meu padrão ir. Mais intuitivo para mim, mais histórico de programação aqui do que qualquer preferência real - reutilização entre idiomas, menos digitação para a maioria das estruturas de dados devido ao preenchimento automático do IDE: P.

• enumerateObject...- quando o acesso ao objeto e ao índice for necessário. E ao acessar estruturas que não são de matriz ou de dicionário (preferência pessoal)

• for (int i=idx; i<count; i++) - para matrizes, quando eu preciso iniciar em um índice diferente de zero