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.
fn main() {
for nomor in 0..5 {
println!("putaran {nomor}");
}
println!("selesai");
}
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:
fn main() {
let mut nomor = 0;
while nomor < 5 {
println!("putaran {nomor}");
nomor += 1;
}
}
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.
fn main() {
for nomor in 1..=3 {
println!("naik {nomor}");
}
for nomor in (1..=3).rev() {
println!("turun {nomor}");
}
}
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.
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);
}
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.
fn main() {
let mut nilai = [70, 85, 90];
for isi in nilai.iter_mut() {
*isi += 5;
}
println!("{:?}", nilai);
}
[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.
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");
}
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.
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}");
}
}
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 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.
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");
}
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.
fn main() {
for nomor in 5 {
println!("{nomor}");
}
}
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.
fn main() {
let mut nilai = [70, 85, 90];
for isi in nilai.iter() {
nilai[0] += 1;
println!("{isi}");
}
}
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.
fn main() {
let batas: u8 = 5;
for nomor in 0..batas {
let lain: i32 = nomor;
println!("{lain}");
}
}
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
forkalau sumber datanya sudah berbentuk rentang, array, slice, atau iterator, karena jumlah putaran mengikuti isi data. - Pakai
whilekalau berhentinya bergantung pada keadaan di luar data, misalnya sisa percobaan atau jawaban pengguna. - Pakai
loopkalau hasil perulangan perlu dikembalikan sebagai nilai, karena hanyaloopyang mendukungbreakbernilai.
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
- Tulis program yang mencetak kuadrat dari 1 sampai 10 memakai
for, lalu bandingkan keluarannya dengan versiwhile. - Ubah contoh
enumeratedi bab ini agar hanya mencetak nilai di atas 80 beserta indeksnya. - Tulis program yang memakai
iter_mutuntuk 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
- The Rust Programming Language. Control Flow.
- The Rust Reference. Loop expressions.
- Rust Standard Library. Trait Iterator.
- Rust Standard Library. Struct Range.