Kapan menggunakan enumerateObjectsUsingBlock vs. for

Selain perbedaan yang jelas:

• Menggunakan enumerateObjectsUsingBlock saat Anda membutuhkan indeks dan objek
• Jangan gunakan enumerateObjectsUsingBlockketika Anda perlu memodifikasi variabel lokal (saya salah tentang ini, lihat jawaban bbum)

Apakah enumerateObjectsUsingBlockumumnya dianggap lebih baik atau lebih buruk ketika for (id obj in myArray)juga akan bekerja? Apa kelebihan / kekurangannya (misalnya performanya kurang lebih)?

Pada akhirnya, gunakan pola apa pun yang ingin Anda gunakan dan datang lebih alami dalam konteks.

Meskipun for(... in ...)cukup nyaman dan singkat secara sintaksis, enumerateObjectsUsingBlock:memiliki sejumlah fitur yang mungkin atau mungkin tidak terbukti menarik:

• enumerateObjectsUsingBlock:akan lebih cepat atau lebih cepat daripada pencacahan cepat ( for(... in ...)menggunakan NSFastEnumerationdukungan untuk mengimplementasikan pencacahan). Penghitungan cepat memerlukan terjemahan dari representasi internal ke representasi untuk penghitungan cepat. Ada overhead di dalamnya. Enumerasi berbasis blok memungkinkan kelas koleksi untuk menghitung konten secepat traversal tercepat dari format penyimpanan asli. Agak tidak relevan untuk array, tetapi bisa menjadi perbedaan besar untuk kamus.

• "Jangan gunakan enumerateObjectsUsingBlock ketika Anda perlu memodifikasi variabel lokal" - tidak benar; Anda dapat mendeklarasikan penduduk lokal Anda sebagai __blockdan mereka akan dapat ditulis di blok.

• enumerateObjectsWithOptions:usingBlock: mendukung enumerasi bersamaan atau terbalik.

• dengan kamus, enumerasi berbasis blok adalah satu-satunya cara untuk mengambil kunci dan nilai secara bersamaan.

Secara pribadi, saya menggunakan enumerateObjectsUsingBlock:lebih sering daripadafor (... in ...) , tetapi - lagi - pilihan pribadi.

Untuk enumerasi sederhana, cukup menggunakan enumerasi cepat (yaitu for…in…loop) adalah opsi yang lebih idiomatis. Metode blok mungkin sedikit lebih cepat, tetapi itu tidak terlalu penting dalam banyak kasus - beberapa program terikat dengan CPU, dan meskipun itu jarang bahwa loop itu sendiri daripada perhitungan di dalamnya akan menjadi hambatan.

Simpul sederhana juga membaca lebih jelas. Inilah pelat dari kedua versi:

for (id x in y){
}

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

Bahkan jika Anda menambahkan variabel untuk melacak indeks, loop sederhana lebih mudah dibaca.

Jadi kapan sebaiknya Anda gunakan enumerateObjectsUsingBlock:? Saat Anda menyimpan blok untuk dieksekusi nanti atau di banyak tempat. Ini bagus untuk saat Anda benar-benar menggunakan blok sebagai fungsi kelas satu daripada pengganti yang terlalu padat untuk bodi loop.

Meskipun pertanyaan ini sudah tua, banyak hal belum berubah, jawaban yang diterima salah.

The enumerateObjectsUsingBlockAPI tidak dimaksudkan untuk menggantikan for-in, tapi untuk kasus penggunaan yang sama sekali berbeda:

• Ini memungkinkan penerapan logika non-lokal yang sewenang-wenang. yaitu Anda tidak perlu tahu apa yang dilakukan blok untuk menggunakannya pada array.
• Pencacahan serentak untuk koleksi besar atau perhitungan berat (menggunakan withOptions:parameter)

Enumerasi cepat dengan for-inmasih idiomatik metode untuk menghitung koleksi.

Penghitungan Cepat mendapat manfaat dari singkatnya kode, keterbacaan, dan optimisasi tambahan yang membuatnya cepat secara tidak wajar. Lebih cepat dari pada C-loop lama!

Tes cepat menyimpulkan bahwa pada tahun 2014 di iOS 7, enumerateObjectsUsingBlock secara konsisten lebih lambat 700% dari pada untuk-in (berdasarkan iterasi 1mm dari array 100 item).

Apakah kinerja merupakan masalah praktis yang nyata di sini?

Jelas tidak, dengan pengecualian langka.

Intinya adalah untuk menunjukkan bahwa ada sedikit keuntungan untuk menggunakan enumerateObjectsUsingBlock:lebih for-intanpa alasan yang benar-benar baik. Itu tidak membuat kode lebih mudah dibaca ... atau lebih cepat ... atau aman utas. (Kesalahpahaman umum lainnya).

Pilihannya adalah preferensi pribadi. Bagi saya, opsi idiomatis dan mudah dibaca menang. Dalam hal ini, yaitu Penghitungan Cepat menggunakan 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);

Hasil:

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

Untuk menjawab pertanyaan tentang kinerja, saya melakukan beberapa tes menggunakan proyek tes kinerja saya . Saya ingin tahu yang mana dari tiga opsi untuk mengirim pesan ke semua objek dalam array yang tercepat.

Pilihannya adalah:

1) makeObjectsPerformSelector

[arr makeObjectsPerformSelector:@selector(_stubMethod)];

2) penghitungan cepat & pengiriman pesan reguler

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

3) enumerateObjectsUsingBlock & kirim pesan biasa

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

Ternyata makeObjectsPerformSelector adalah yang paling lambat sejauh ini. Butuh pencacahan dua kali lebih lama. Dan enumerateObjectsUsingBlock adalah yang tercepat, itu sekitar 15-20% lebih cepat dari iterasi cepat.

Jadi, jika Anda sangat khawatir tentang kinerja terbaik, gunakan enumerateObjectsUsingBlock. Tetapi perlu diingat bahwa dalam beberapa kasus waktu yang diperlukan untuk menghitung koleksi dikerdilkan oleh waktu yang diperlukan untuk menjalankan kode apa pun yang Anda ingin setiap objek dieksekusi.

Ini cukup berguna untuk menggunakan enumerateObjectsUsingBlock sebagai loop luar ketika Anda ingin memecah loop bersarang.

misalnya

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

Alternatifnya adalah menggunakan pernyataan goto.

Terima kasih kepada @bbum dan @Chuck untuk memulai perbandingan komprehensif tentang kinerja. Senang mengetahui ini sepele. Saya sepertinya telah mengikuti:

• for (... in ...)- sebagai goto default saya. Lebih intuitif bagi saya, lebih banyak sejarah pemrograman di sini daripada preferensi sebenarnya - penggunaan kembali lintas bahasa, kurang mengetik untuk sebagian besar struktur data karena IDE otomatis lengkap: P.

• enumerateObject...- ketika akses ke objek dan indeks diperlukan. Dan ketika mengakses struktur non-array atau kamus (preferensi pribadi)

• for (int i=idx; i<count; i++) - untuk array, ketika saya harus mulai dengan indeks yang tidak nol