BAB 10: Perulangan, while
Perulangan while di Rust: kondisi bool, break dan continue, mutability penghitung, serta pesan kompilator yang muncul saat salah menulisnya.
Program yang mencetak 3 baris sering ditulis dengan 3 pemanggilan println!. Pola itu berhenti bekerja begitu jumlah barisnya ditentukan saat program berjalan, misalnya sebanyak jumlah data yang dibaca dari berkas. Perulangan mengambil alih bagian itu: 1 blok kode, dijalankan berulang selama kondisinya benar.
Rust menyediakan 3 bentuk perulangan, yaitu while, loop, dan for. Bab ini khusus membahas while, termasuk pesan kompilator yang muncul saat kondisi atau penghitungnya salah ditulis. Semua contoh di bab ini dikompilasi dengan rustc 1.100.0, dan keluarannya diambil dari program yang dijalankan.
Bentuk dasar while
while menjalankan blok kode selama kondisinya bernilai true. Kondisi diperiksa sebelum blok dijalankan, sehingga blok bisa saja tidak pernah berjalan sama sekali.
fn main() {
let mut hitungan = 1;
while hitungan <= 3 {
println!("hitungan ke-{hitungan}");
hitungan += 1;
}
}
Keluarannya:
hitungan ke-1
hitungan ke-2
hitungan ke-3
3 hal yang wajib ada pada pola ini: variabel penghitung yang mut, kondisi yang bisa berubah menjadi false, dan perubahan nilai di dalam blok. Kalau salah satunya hilang, perulangan berjalan selamanya atau tidak berjalan sama sekali.
Kondisi harus bertipe bool
Rust tidak mengubah tipe lain menjadi bool secara otomatis. Angka 1 bukan true, dan angka 0 bukan false. Menulis angka sebagai kondisi langsung ditolak kompilator:
fn main() {
let x = 1;
while x {
println!("{x}");
}
}
Pesan yang keluar saat dikompilasi:
error[E0308]: mismatched types
--> while_nonbool.rs:4:11
|
4 | while x {
| ^ expected `bool`, found integer
Perbaikannya menulis perbandingan yang jelas, misalnya while x != 0. Kebiasaan dari bahasa lain yang menganggap 0 sebagai salah harus ditinggalkan saat menulis Rust.
Penghitung harus mutable
Variabel di Rust tidak bisa diubah setelah dibuat, kecuali dideklarasikan dengan mut. Kesalahan ini sering terjadi pada perulangan, karena penghitung memang harus berubah setiap putaran:
fn main() {
let hitungan = 1;
while hitungan <= 3 {
println!("{hitungan}");
hitungan += 1;
}
}
error[E0384]: cannot assign twice to immutable variable `hitungan`
--> while_immutable.rs:6:9
|
3 | let hitungan = 1;
| -------- first assignment to `hitungan`
...
6 | hitungan += 1;
| ^^^^^^^^^^^^^ cannot assign twice to immutable variable
|
help: consider making this binding mutable
|
3 | let mut hitungan = 1;
Kompilator tidak hanya menolak, tetapi juga menunjukkan baris yang harus diubah. Perhatikan bahwa pesan ini muncul saat kompilasi, bukan saat program berjalan, sehingga kesalahan seperti ini tidak pernah sampai ke pengguna.
Membaca array lewat indeks
while sering dipakai untuk mengakses elemen array satu per satu memakai indeks. Panjang array diambil dengan .len(), sehingga batas perulangan tidak perlu ditulis sebagai angka tetap.
fn main() {
let nilai = [10, 20, 30];
let mut i = 0;
while i < nilai.len() {
println!("nilai[{i}] = {}", nilai[i]);
i += 1;
}
}
nilai[0] = 10
nilai[1] = 20
nilai[2] = 30
Pola ini bekerja, tetapi punya 1 risiko: kalau kondisi perulangan salah dan i melewati batas, akses nilai[i] akan menyebabkan program berhenti dengan panic. Rust memeriksa batas indeks saat program berjalan, jadi kesalahan itu tidak menghasilkan pembacaan memori di luar array. Untuk kasus membaca seluruh elemen, for lebih aman karena tidak memerlukan indeks, dan bentuk itu dibahas di bab 12.
break dan continue
break menghentikan perulangan seketika, sedangkan continue melewati sisa blok dan langsung memeriksa kondisi lagi. Keduanya dipakai untuk mengatur alur di dalam while.
fn main() {
let mut angka = 1;
while angka <= 10 {
if angka == 4 {
println!("berhenti di {angka}");
break;
}
angka += 1;
}
}
berhenti di 4
continue berguna untuk melewati nilai yang tidak perlu diproses:
fn main() {
let mut n = 0;
while n < 6 {
n += 1;
if n % 2 == 0 {
continue;
}
println!("ganjil: {n}");
}
}
ganjil: 1
ganjil: 3
ganjil: 5
Perhatikan urutan penulisan pada contoh itu: n += 1 diletakkan sebelum continue. Kalau continue ditulis sebelum penambahan, n tidak pernah berubah dan perulangan berjalan selamanya. Kesalahan urutan seperti ini tidak ditolak kompilator, karena secara sintaks semuanya sah.
while true dan peringatan kompilator
Menulis while true adalah cara yang sah untuk membuat perulangan tanpa kondisi berhenti di awal, tetapi kompilator memberi peringatan:
fn main() {
let mut coba = 0;
while true {
coba += 1;
if coba == 2 {
break;
}
}
println!("percobaan: {coba}");
}
warning: denote infinite loops with `loop { ... }`
--> while_demo.rs:39:5
|
39 | while true {
| ^^^^^^^^^^ help: use `loop`
|
= note: `#[warn(while_true)]` on by default
Peringatan while_true muncul karena Rust punya bentuk khusus untuk perulangan tanpa akhir, yaitu loop. Bedanya lebih dari soal gaya penulisan: loop bisa mengembalikan nilai lewat break, sedangkan while tidak. Bab berikutnya membahas perbedaan itu.
while tidak menghasilkan nilai
Setiap ekspresi di Rust punya tipe. while bertipe (), artinya ia tidak menghasilkan nilai yang bisa disimpan. Karena itu kode berikut tidak akan pernah mengembalikan angka yang diharapkan:
fn main() {
// while bertipe (), jadi hasil berisi ()
let hasil = while false {};
println!("{hasil:?}");
}
Kalau nilai dari dalam perulangan dibutuhkan, bentuk yang tepat adalah loop dengan break bernilai:
fn main() {
let hasil = loop {
break 42;
};
println!("hasil = {hasil}");
}
hasil = 42
Batas tipe penghitung
Penghitung perulangan punya tipe, dan tipenya menentukan batas nilai. Memakai u8 untuk penghitung yang naik sampai 255 menghasilkan 2 hal sekaligus: peringatan kompilator, lalu panic saat program berjalan.
fn main() {
let mut n: u8 = 255;
while n <= 255 {
println!("{n}");
n += 1;
}
}
warning: comparison is useless due to type limits
--> while_u8.rs:3:11
|
3 | while n <= 255 {
| ^^^^^^^^
|
= note: `#[warn(unused_comparisons)]` on by default
Peringatan itu benar: nilai u8 tidak mungkin lebih dari 255, sehingga perbandingan n <= 255 selalu benar. Saat program dijalankan, hasilnya:
thread 'main' panicked at while_u8.rs:5:9:
attempt to add with overflow
Pada build debug, penambahan yang melewati batas tipe menghentikan program. Pada build release, perilakunya berbeda: nilainya berputar kembali ke 0 tanpa pesan. 2 perilaku berbeda untuk kode yang sama ini alasan penghitung sebaiknya memakai usize atau u64, yang batasnya jauh di atas kebutuhan perulangan biasa.
Kapan memakai while
while tepat dipakai ketika jumlah putaran tidak diketahui di awal, dan perulangan berhenti karena suatu kondisi di tengah proses. Contohnya membaca baris sampai penanda tertentu ditemukan, menunggu nilai berubah, atau mengulang percobaan sampai berhasil.
| Kebutuhan | Bentuk yang tepat |
|---|---|
| jumlah putaran sudah diketahui | for dengan rentang |
| berhenti saat kondisi tertentu | while |
| berhenti sambil mengembalikan nilai | loop dengan break bernilai |
| membaca seluruh elemen koleksi | for tanpa indeks |
Kalau jumlah putaran sudah diketahui, misalnya 1 sampai 10, for lebih ringkas karena penghitung, kondisi, dan penambahan ditulis dalam 1 baris. Kalau berhentinya bergantung pada kondisi yang hanya diketahui saat program berjalan, while lebih alami.
Ringkasan
while menjalankan blok selama kondisinya true, dengan kondisi yang wajib bertipe bool dan penghitung yang wajib dideklarasikan mut. Perubahan nilai penghitung harus ditulis di dalam blok, dan urutannya menentukan apakah perulangan berhenti atau berjalan selamanya.
break menghentikan perulangan, continue melewati sisa blok dan memeriksa kondisi lagi. while true sah ditulis, tetapi kompilator menyarankan loop karena bentuk itu bisa mengembalikan nilai lewat break.
Untuk membaca seluruh elemen koleksi, for lebih tepat karena tidak memerlukan indeks dan tidak berisiko melewati batas array.
Referensi
- The Rust Programming Language. Control Flow, Repetition with Loops.
- The Rust Reference. Loop expressions.
- Standard library. Keyword while.
- Standard library. Keyword loop.
- The rustc book. Warn-by-default lints, while_true.