BAB 11: Perulangan, loop, break, continue, label
Perulangan loop di Rust: keluar dengan break, melewati putaran dengan continue, mengambil nilai dari loop, dan label untuk perulangan bersarang.
Program yang menunggu jawaban pengguna tidak tahu berapa kali ia harus bertanya. Selama jawaban yang masuk belum sesuai aturan, program harus mengulang. while tidak nyaman untuk kasus itu karena kondisinya ditulis di awal, sementara berhentinya baru diketahui di tengah blok. Rust menyediakan loop untuk keadaan seperti ini: perulangan tanpa kondisi, dan keputusan berhenti diambil dari dalam blok.
Bab ini membahas loop beserta 3 kata kunci yang menemaninya, yaitu break, continue, dan label. Setelah bab ini selesai, kamu dapat menulis perulangan yang berhenti tepat pada kondisi yang kamu tentukan, melewati putaran tertentu, dan keluar dari perulangan bersarang tanpa bendera tambahan. Semua contoh dikompilasi dengan rustc 1.100.0 dan keluarannya diambil dari program yang dijalankan di mesin ini.
Bentuk dasar loop
loop menjalankan blok kode berulang tanpa memeriksa kondisi apa pun. Satu-satunya cara keluar adalah break di dalam blok, atau program dihentikan dari luar.
fn main() {
let mut hitungan = 1;
loop {
println!("putaran ke-{hitungan}");
if hitungan == 3 {
break;
}
hitungan += 1;
}
println!("selesai");
}
Keluarannya:
putaran ke-1
putaran ke-2
putaran ke-3
selesai
Perhatikan urutan di dalam blok. Pemeriksaan hitungan == 3 diletakkan sebelum penambahan, sehingga angka 3 sempat dicetak sebelum perulangan berhenti. Kalau pemeriksaan dipindah ke awal blok, keluaran yang muncul hanya 2 baris. Urutan pemeriksaan dan pencetakan menentukan isi keluaran, dan itu bukan detail gaya penulisan.
break boleh ditulis di mana saja di dalam blok, termasuk di dalam if seperti contoh di atas. Setelah break dijalankan, kendali pindah ke baris pertama setelah blok loop, sehingga println!("selesai") ikut dijalankan.
Akibat lupa menulis break
Tanpa break, loop berjalan sampai program dihentikan. Ini bukan kesalahan kompilasi, karena kompilator tidak memeriksa apakah perulangan akan berhenti. Untuk mengukurnya, program berikut dijalankan dengan batas waktu 2 detik:
fn main() {
let mut hitungan = 0;
loop {
hitungan += 1;
println!("putaran {hitungan}");
}
}
Hasil pengukuran di mesin ini: perintah timeout 2 ./loop_hang dengan keluaran dialihkan ke berkas berhenti dengan kode keluar 124, dan berkas itu berisi 1.038.191 baris, dengan baris terakhir putaran 1038191. Jumlah baris itu bergantung pada kecepatan mesin, jadi angka pastinya akan berbeda di komputer lain. Yang tetap sama adalah sifatnya: program tidak berhenti sendiri.
Kode keluar 124 adalah tanda bahwa timeout yang menghentikan program, bukan program yang selesai. Kalau break lupa ditulis pada program yang membaca masukan pengguna, program akan menunggu selamanya dan tampak menggantung.
loop dapat menghasilkan nilai
Perbedaan penting antara loop dan while adalah loop bisa dipakai sebagai ekspresi yang menghasilkan nilai. Nilai itu datang dari break yang ditulis dengan argumen:
fn main() {
let mut percobaan = 0;
let jawaban = loop {
percobaan += 1;
if percobaan == 3 {
break percobaan * 10;
}
};
println!("berhenti di percobaan {percobaan}");
println!("nilai hasil loop: {jawaban}");
}
berhenti di percobaan 3
nilai hasil loop: 30
Pola ini berguna saat nilai akhir baru diketahui setelah beberapa putaran, misalnya hasil pencarian di dalam daftar atau percobaan koneksi sampai berhasil. Tanpa kemampuan ini, kamu perlu variabel mut tambahan di luar perulangan untuk menyimpan hasilnya.
Satu aturan yang berlaku: break bernilai hanya boleh dipakai di dalam loop, tidak di dalam while atau for. Alasannya, while dan for bisa berakhir tanpa pernah menjalankan break, sehingga nilainya tidak selalu ada. Rust menolak pola itu saat kompilasi, dan pesan errornya dibahas di bagian berikutnya.
continue untuk melewati putaran
continue menghentikan putaran saat ini dan langsung memeriksa kondisi putaran berikutnya. Sisa kode di bawah continue tidak dijalankan pada putaran itu.
fn main() {
let mut angka = 0;
loop {
angka += 1;
if angka > 6 {
break;
}
if angka % 2 == 0 {
continue;
}
println!("angka ganjil: {angka}");
}
}
angka ganjil: 1
angka ganjil: 3
angka ganjil: 5
Ada 2 jalur keluar di dalam blok itu. break dipakai saat angka melewati 6, dan continue dipakai saat angka genap. Tanpa continue, program tetap benar tetapi memerlukan blok if tambahan untuk membungkus println!, sehingga kode masuk satu tingkat lebih dalam.
Satu jebakan yang sering terjadi pada loop dengan continue: penambahan penghitung diletakkan setelah continue, sehingga tidak pernah dijalankan dan perulangan berjalan selamanya. Pada contoh di atas, angka += 1 ditulis paling atas supaya selalu dieksekusi.
Perulangan bersarang dan label
Perulangan di dalam perulangan sering dipakai untuk data 2 dimensi, misalnya baris dan kolom. break dan continue pada bentuk ini hanya berlaku untuk perulangan terdalam. Untuk keluar dari perulangan luar, Rust memakai label.
fn main() {
let mut baris = 0;
'luar: loop {
baris += 1;
let mut kolom = 0;
loop {
kolom += 1;
if baris == 2 && kolom == 2 {
println!("berhenti di baris {baris} kolom {kolom}");
break 'luar;
}
if kolom > 3 {
break;
}
println!("baris {baris} kolom {kolom}");
}
}
println!("keluar dari kedua perulangan");
}
baris 1 kolom 1
baris 1 kolom 2
baris 1 kolom 3
baris 2 kolom 1
berhenti di baris 2 kolom 2
keluar dari kedua perulangan
Label ditulis dengan tanda kutip tunggal di depan nama, seperti 'luar. Dokumentasi Rust Book menyebut aturan ini secara eksplisit: "Loop labels must begin with a single quote." Setelah label dipasang, break 'luar menghentikan perulangan luar dan seluruh perulangan di dalamnya sekaligus.
Gambar di atas menunjukkan alur pada contoh label. Kotak biru menandai titik masuk dan titik keluar, kotak abu bergaris putus-putus adalah langkah yang diulang pada loop dalam, dan kotak merah adalah break 'luar. Selama syarat baris == 2 && kolom == 2 belum benar, kendali kembali ke kolom += 1 lewat jalur tidak. Begitu syaratnya benar, break 'luar menghentikan kedua perulangan lalu program berlanjut ke baris setelah loop.
Tanpa label, penyelesaian yang biasa dipakai adalah variabel bool di luar perulangan yang diperiksa di setiap tingkat. Cara itu benar, tetapi menambah satu variabel dan satu pemeriksaan untuk setiap tingkat perulangan. Label menghapus keduanya.
Contoh: mencari nilai dengan batas
Contoh berikut menggabungkan break bernilai, continue, dan batas akhir data dalam satu program. Program mencari angka ganjil pertama yang nilainya di atas 10 dari sebuah array.
fn main() {
let data = [3, 8, 15, 22];
let mut indeks = 0;
let ketemu = loop {
if indeks >= data.len() {
break None;
}
let nilai = data[indeks];
indeks += 1;
if nilai % 2 == 0 {
continue;
}
if nilai > 10 {
break Some(nilai);
}
};
match ketemu {
Some(n) => println!("angka ganjil di atas 10: {n}"),
None => println!("tidak ada yang cocok"),
}
}
angka ganjil di atas 10: 15
Ada 3 hal yang perlu diperhatikan pada program itu. Pemeriksaan indeks >= data.len() menjaga agar data[indeks] tidak dibaca melewati batas, karena pengindeksan di luar batas membuat program panic. continue melewati angka genap tanpa keluar dari perulangan. break di akhir membawa Some(nilai) sehingga hasil pencarian langsung diterima ketemu.
Nilai None pada break pertama membuat tipe ketemu menjadi Option<i32>, dan itu sebabnya match di bawahnya punya 2 cabang. Rust menyimpulkan tipe dari kedua break yang ada, jadi kamu tidak perlu menulis tipe Option<i32> secara manual.
2 pesan error yang muncul saat memakai break
Kesalahan pertama adalah memakai break bernilai di dalam while:
fn main() {
let mut angka = 0;
while angka < 5 {
angka += 1;
if angka == 3 {
break angka;
}
}
}
Pesan yang keluar saat dikompilasi:
error[E0571]: `break` with value from a `while` loop
--> salah_break_while.rs:8:13
|
4 | while angka < 5 {
| --------------- you can't `break` with a value in a `while` loop
...
8 | break angka;
| ^^^^^^^^^^^ can only break with a value inside `loop` or breakable block
|
help: use `break` on its own without a value inside this `while` loop
|
8 - break angka;
8 + break;
|
Kompilator tidak hanya menolak, tetapi juga menunjukkan perbaikannya. Kalau nilai angka memang dibutuhkan setelah perulangan, deklarasikan angka di luar dan biarkan break tanpa nilai, karena nilainya sudah tersimpan di variabel itu.
Kesalahan kedua adalah menulis break di luar perulangan:
fn main() {
let nilai = 5;
if nilai > 3 {
break;
}
println!("{nilai}");
}
error[E0268]: `break` outside of a loop or labeled block
--> salah_break_luar.rs:5:9
|
5 | break;
| ^^^^^ cannot `break` outside of a loop or labeled block
Pesan ini biasanya muncul saat kode perulangan dipindahkan ke dalam fungsi lain, lalu break ikut terbawa. Perbaikannya mengembalikan break ke dalam blok perulangan, atau memakai return kalau tujuannya menghentikan fungsi.
Memilih antara loop dan while
3 patokan berikut cukup untuk menentukan pilihan:
- Pakai
loopkalau kondisi berhenti baru bisa dihitung di tengah blok, misalnya setelah membaca masukan atau memeriksa hasil percobaan. - Pakai
loopkalau hasil perulangan perlu dikembalikan sebagai nilai, karena hanyaloopyang mendukungbreakbernilai. - Pakai
whilekalau kondisi berhenti sederhana dan bisa ditulis di awal, misalnya selama penghitung masih di bawah batas.
Keduanya bisa saling menggantikan secara fungsi, karena while kondisi setara dengan loop yang diakhiri if !kondisi { break; }. Pilihan yang tepat adalah yang membuat maksud kode paling mudah dibaca.
Latihan
- Tulis program yang memakai
loopdanbreakbernilai untuk mencari angka pertama di atas 100 yang habis dibagi 7, lalu cetak hasilnya. - Ubah contoh label di bab ini agar perulangan berhenti pada baris 3 kolom 2, lalu bandingkan keluarannya dengan keluaran sebelumnya.
Ringkasan
loop menjalankan blok tanpa memeriksa kondisi, dan berhenti hanya lewat break. break dapat membawa nilai sehingga hasil perulangan bisa langsung dipakai, sedangkan continue melewati sisa putaran. Untuk perulangan bersarang, label berawalan tanda kutip tunggal memungkinkan break keluar dari perulangan luar. Lupa menulis break tidak ditolak kompilator, tetapi membuat program berjalan terus: pada pengukuran di bab ini dengan keluaran dialihkan ke berkas, 1.038.191 baris tercetak dalam 2 detik sebelum proses dihentikan.
Referensi
- The Rust Reference. Loop expressions.
- The Rust Programming Language. Control Flow.