Foundation

BAB 12: Perulangan, for in

Perulangan for in di Rust untuk menelusuri rentang dan array, dengan enumerate, iter_mut, step_by, continue, break, dan label.

Program pencarian di bab sebelumnya menulis sendiri 3 hal sekaligus: variabel indeks yang mulai dari 0, pemeriksaan indeks >= data.len() di setiap putaran, dan penambahan indeks += 1 di akhir blok. Ketiganya benar, tetapi semuanya bisa salah: satu penambahan yang tertinggal membuat perulangan berjalan tanpa henti, dan satu pemeriksaan batas yang lupa ditulis membuat program membaca elemen di luar array lalu panic.

Rust menyediakan for untuk mengambil alih ketiga pekerjaan itu. Bab ini membahas for pada rentang angka dan array, lalu 3 cara mengubah perilakunya, yaitu enumerate untuk memperoleh nomor urut, iter_mut untuk mengubah isi elemen, dan step_by untuk melompat. Setelah bab ini selesai, kamu dapat menelusuri data tanpa menghitung indeks sendiri, mengubah elemen di tempat, dan menghentikan perulangan tepat pada nilai yang dicari. Semua contoh dikompilasi dengan rustc 1.100.0 dan keluarannya disalin dari program yang dijalankan di mesin ini.

Bentuk dasar for dengan rentang

Sumber data paling sederhana untuk for adalah rentang angka. Rentang ditulis dengan .. dan menghasilkan nilai dari batas kiri sampai satu angka sebelum batas kanan.

RSRUST
fn main() {
    for nomor in 0..5 {
        println!("putaran {nomor}");
    }

    println!("selesai");
}
CodeTEXT
putaran 0
putaran 1
putaran 2
putaran 3
putaran 4
selesai

Ada 2 hal yang perlu diperhatikan pada keluaran itu. Angka 5 tidak pernah tercetak, karena 0..5 berhenti sebelum batas kanan. Tidak ada variabel penghitung di dalam program, karena for mengambil nilai berikutnya dari rentang sampai rentang itu habis.

Kalimat for nomor in 0..5 menyatakan maksud yang sama dengan while di bawah ini, tetapi dengan satu baris sebagai sumber nilai:

RSRUST
fn main() {
    let mut nomor = 0;

    while nomor < 5 {
        println!("putaran {nomor}");
        nomor += 1;
    }
}
CodeTEXT
putaran 0
putaran 1
putaran 2
putaran 3
putaran 4

Keluarannya identik dengan program sebelumnya. Perbedaannya ada pada tanggung jawab: versi while menyimpan keadaan perulangan di variabel nomor yang terlihat dan bisa diubah dari mana saja di dalam blok, sedangkan versi for menyimpan keadaan itu di dalam rentang. The Rust Book menyebut alasan pemakaiannya dengan kalimat "most Rustaceans would use a for loop", dan menyebut rentang sebagai penghasil angka berurutan.

Rentang inklusif dan arah terbalik

Batas kanan yang ikut dihitung ditulis dengan ..=. Selisih satu karakter itu mengubah jumlah putaran, dan pada data berukuran kecil selisihnya mudah terlihat.

RSRUST
fn main() {
    for nomor in 1..=3 {
        println!("naik {nomor}");
    }

    for nomor in (1..=3).rev() {
        println!("turun {nomor}");
    }
}
CodeTEXT
naik 1
naik 2
naik 3
turun 3
turun 2
turun 1

Rentang juga bisa dibalik, karena rev tersedia untuk iterator yang bisa dibaca dari kedua ujung. Dokumentasi Iterator menjelaskan rev dengan kalimat "Reverses an iterator's direction." Tanpa rev, menelusuri data dari belakang memerlukan indeks manual yang mulai dari len() - 1 dan berkurang, dan pola itu membuka kembali kesempatan salah menghitung batas.

Menelusuri array dan memakai enumerate

Array bisa langsung dipakai sebagai sumber for. Kalau nomor urut dibutuhkan, enumerate menambahkan pasangan indeks dan isi.

RSRUST
fn main() {
    let nilai = [70, 85, 90];

    for (indeks, isi) in nilai.iter().enumerate() {
        println!("indeks {indeks}: {isi}");
    }

    let mut total = 0;
    for isi in nilai {
        total += isi;
    }

    println!("total {total}");
    println!("rata-rata {}", total / nilai.len() as i32);
}
CodeTEXT
indeks 0: 70
indeks 1: 85
indeks 2: 90
total 245
rata-rata 81

Pola (indeks, isi) di dalam tanda kurung disebut pola tuple, dan di situ enumerate membagi hasilnya menjadi 2 nilai. Dokumentasi Iterator menuliskan enumerate sebagai metode yang "gives the current iteration count as well as the next value".

Bagian kedua program memakai for isi in nilai tanpa .iter(). Pada bentuk ini array diserahkan ke perulangan, dan karena array i32 dapat disalin, variabel nilai masih bisa dipakai sesudahnya untuk nilai.len(). Rata-rata yang tercetak adalah 81, bukan 81,67, karena total dan len() sama-sama bilangan bulat sehingga pembagiannya dibulatkan ke bawah.

Mengubah isi elemen saat iterasi

iter() meminjamkan elemen sebagai referensi, jadi isinya tidak bisa diubah lewat variabel perulangan. Untuk mengubah elemen di tempat, metode yang dipakai adalah iter_mut, dan hasilnya berupa referensi yang bisa diubah.

RSRUST
fn main() {
    let mut nilai = [70, 85, 90];

    for isi in nilai.iter_mut() {
        *isi += 5;
    }

    println!("{:?}", nilai);
}
CodeTEXT
[75, 90, 95]

Tanda * di depan isi diperlukan karena isi adalah referensi, bukan nilai. Tanpa tanda itu, penambahan berlaku pada referensi, bukan pada angka yang ditunjuk. Array juga harus dideklarasikan mut, karena perubahan isi termasuk perubahan data.

Melompati putaran dengan step_by

step_by mengambil satu nilai lalu melewati sejumlah nilai berikutnya. Metode ini dipakai saat data yang dibutuhkan berjarak tetap, misalnya setiap elemen ketiga.

RSRUST
fn main() {
    let mut jumlah = 0;

    for nomor in (1..20).step_by(3) {
        jumlah += nomor;
    }

    println!("jumlah {jumlah}");

    for nomor in 5..1 {
        println!("tidak pernah tercetak {nomor}");
    }

    println!("rentang terbalik selesai tanpa satu pun putaran");
}
CodeTEXT
jumlah 70
rentang terbalik selesai tanpa satu pun putaran

Rentang (1..20).step_by(3) melewati 7 nilai, yaitu 1, 4, 7, 10, 13, 16, dan 19, dan jumlahnya 70. Dokumentasi Iterator menuliskan step_by sebagai metode yang membuat iterator bergerak "by the given amount at each iteration".

Bagian kedua program menunjukkan perilaku yang perlu diketahui: rentang 5..1 tidak berisi angka, sehingga blok for tidak pernah dijalankan dan tidak ada pesan error. Kompilator tidak menganggap rentang terbalik sebagai kesalahan, karena rentang kosong adalah rentang yang sah. Kalau kamu menulis batas dengan urutan terbalik, gejalanya bukan error, melainkan keluaran yang kosong.

break dan continue di dalam for

break dan continue berlaku sama pada for seperti pada loop dan while. Program berikut menilai 5 angka, melewati angka di bawah 60, berhenti saat menemukan nilai 100, dan mencetak sisanya.

RSRUST
fn main() {
    let nilai = [55, 72, 90, 48, 100];

    for (indeks, isi) in nilai.iter().enumerate() {
        if *isi < 60 {
            println!("indeks {indeks} tidak lulus, dilewati");
            continue;
        }

        if *isi == 100 {
            println!("nilai sempurna di indeks {indeks}, berhenti");
            break;
        }

        println!("indeks {indeks} lulus dengan {isi}");
    }
}
CodeTEXT
indeks 0 tidak lulus, dilewati
indeks 1 lulus dengan 72
indeks 2 lulus dengan 90
indeks 3 tidak lulus, dilewati
nilai sempurna di indeks 4, berhenti
Alur for pada array nilai: elemen diambil satu per satu, diperiksa apakah isinya kurang dari 60 lalu apakah sama dengan 100, dan hanya elemen yang lolos kedua pemeriksaan yang dicetak

Alur program di atas untuk 1 elemen. Jalur biru adalah jalur yang dijalankan elemen bernilai 72, sedangkan kotak continue dan break adalah 2 jalan keluar yang dipakai elemen lain.

Gambar itu memperlihatkan bahwa continue tidak menghentikan perulangan, hanya mempercepat putaran. Setelah continue, kendali kembali ke pengambilan elemen berikutnya dan 2 pemeriksaan di atas diulang. break berbeda: kendali keluar dari blok for dan perulangan selesai, sehingga elemen sesudah nilai 100 tidak pernah diperiksa.

Perhatikan juga *isi pada kedua pemeriksaan. Karena iter() meminjamkan elemen, isi bertipe &i32, sehingga perbandingan dilakukan pada nilai yang ditunjuk.

Label pada for bersarang

for di dalam for sering dipakai untuk data 2 dimensi, dan break pada bentuk itu hanya menghentikan perulangan terdalam. Label memberi nama pada perulangan luar supaya break bisa langsung keluar dari keduanya.

RSRUST
fn main() {
    'baris: for b in 1..=3 {
        for k in 1..=3 {
            if b == 2 && k == 2 {
                println!("berhenti di baris {b} kolom {k}");
                break 'baris;
            }
            println!("baris {b} kolom {k}");
        }
    }

    println!("selesai");
}
CodeTEXT
baris 1 kolom 1
baris 1 kolom 2
baris 1 kolom 3
baris 2 kolom 1
berhenti di baris 2 kolom 2
selesai

Label 'baris ditulis dengan tanda kutip tunggal di depan nama, dan break 'baris menghentikan perulangan yang memakai label itu beserta seluruh perulangan di dalamnya. Tanpa label, penyelesaian yang biasa dipakai adalah variabel bool di luar perulangan yang diperiksa di setiap tingkat, dan cara itu menambah satu variabel untuk setiap tingkat tambahan.

3 pesan error yang muncul saat memakai for

Kesalahan pertama adalah menulis angka langsung sebagai sumber perulangan. Angka bukan iterator, dan kompilator menolaknya dengan E0277.

RSRUST
fn main() {
    for nomor in 5 {
        println!("{nomor}");
    }
}
CodeTEXT
error[E0277]: `{integer}` is not an iterator
 --> salah_bukan_iterator.rs:2:18
  |
2 |     for nomor in 5 {
  |                  ^ `{integer}` is not an iterator
  |
  = help: the trait `Iterator` is not implemented for `{integer}`
  = note: if you want to iterate between `start` until a value `end`, use the exclusive range syntax `start..end` or the inclusive range syntax `start..=end`
  = note: required for `{integer}` to implement `IntoIterator`

Pesan itu langsung menyebut perbaikannya: ganti 5 dengan 0..5 atau 0..=5. Perhatikan bahwa nomor di dalam blok juga tidak bisa dipakai sebelum sumbernya benar, karena tipe elemen belum diketahui.

Kesalahan kedua adalah mengubah array saat array itu sedang ditelusuri. iter() meminjam array selama perulangan berjalan, sehingga penulisan ke elemen ditolak dengan E0506.

RSRUST
fn main() {
    let mut nilai = [70, 85, 90];

    for isi in nilai.iter() {
        nilai[0] += 1;
        println!("{isi}");
    }
}
CodeTEXT
error[E0506]: cannot assign to `nilai[_]` because it is borrowed
 --> salah_ubah_saat_iterasi.rs:5:9
  |
4 |     for isi in nilai.iter() {
  |                ------------
  |                |
  |                `nilai[_]` is borrowed here
  |                borrow later used here
5 |         nilai[0] += 1;
  |         ^^^^^^^^^^^^^ `nilai[_]` is assigned to here but it was already borrowed

Perbaikannya ada 2: kumpulkan perubahan ke variabel lain lalu tulis sesudah perulangan, atau pakai iter_mut() kalau yang diubah adalah elemen yang sedang ditelusuri. Yang tidak boleh adalah meminjam array untuk dibaca dan menulisnya pada saat yang sama.

Kesalahan ketiga berkaitan dengan tipe elemen. Tipe elemen mengikuti tipe batas rentang, sehingga rentang dengan batas u8 menghasilkan elemen u8, bukan i32.

RSRUST
fn main() {
    let batas: u8 = 5;

    for nomor in 0..batas {
        let lain: i32 = nomor;
        println!("{lain}");
    }
}
CodeTEXT
error[E0308]: mismatched types
 --> salah_tipe_rentang.rs:5:25
  |
5 |         let lain: i32 = nomor;
  |                   ---   ^^^^^ expected `i32`, found `u8`
  |                   |
  |                   expected due to this
  |
help: you can convert a `u8` to an `i32`
  |
5 |         let lain: i32 = nomor.into();
  |                              +++++++

Kompilator menawarkan nomor.into() sebagai perbaikan, dan saran itu benar karena u8 bisa diubah ke i32 tanpa kehilangan data. Untuk arah sebaliknya, i32 ke u8, konversi harus memakai try_into() karena nilainya belum tentu muat.

Memilih for atau while

3 patokan berikut cukup untuk menentukan pilihan:

  • Pakai for kalau sumber datanya sudah berbentuk rentang, array, slice, atau iterator, karena jumlah putaran mengikuti isi data.
  • Pakai while kalau berhentinya bergantung pada keadaan di luar data, misalnya sisa percobaan atau jawaban pengguna.
  • Pakai loop kalau hasil perulangan perlu dikembalikan sebagai nilai, karena hanya loop yang mendukung break bernilai.

Pada data yang sudah punya iterator, for menghapus 2 kesempatan salah sekaligus: indeks yang meleset satu dan pemeriksaan batas yang lupa ditulis. Pada keadaan yang tidak terikat data, while lebih jujur karena kondisinya terlihat di baris pertama.

Latihan

  1. Tulis program yang mencetak kuadrat dari 1 sampai 10 memakai for, lalu bandingkan keluarannya dengan versi while.
  2. Ubah contoh enumerate di bab ini agar hanya mencetak nilai di atas 80 beserta indeksnya.
  3. Tulis program yang memakai iter_mut untuk menaikkan semua nilai di bawah 60 menjadi 60, lalu cetak array sebelum dan sesudah perubahan.

Ringkasan

for mengambil nilai dari sebuah iterator sampai iterator itu habis, sehingga penghitung dan pemeriksaan batas tidak perlu ditulis sendiri. enumerate menambahkan nomor urut, iter_mut memungkinkan perubahan elemen di tempat, dan step_by melewati sejumlah nilai di antara 2 elemen yang dipakai. continue mempercepat satu putaran, break keluar dari perulangan, dan label membuat break keluar dari perulangan luar pada bentuk bersarang. Pada bab ini 3 pesan error dibuktikan dengan kompilasi: E0277 saat angka dipakai sebagai sumber, E0506 saat array diubah ketika sedang dipinjam, dan E0308 saat tipe elemen rentang tidak cocok dengan tipe tujuan.

Referensi

  1. The Rust Programming Language. Control Flow.
  2. The Rust Reference. Loop expressions.
  3. Rust Standard Library. Trait Iterator.
  4. Rust Standard Library. Struct Range.