Foundation

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.

RSRUST
fn main() {
    let mut hitungan = 1;

    while hitungan <= 3 {
        println!("hitungan ke-{hitungan}");
        hitungan += 1;
    }
}

Keluarannya:

CodeTEXT
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:

RSRUST
fn main() {
    let x = 1;
    while x {
        println!("{x}");
    }
}

Pesan yang keluar saat dikompilasi:

CodeTEXT
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:

RSRUST
fn main() {
    let hitungan = 1;
    while hitungan <= 3 {
        println!("{hitungan}");
        hitungan += 1;
    }
}
CodeTEXT
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.

RSRUST
fn main() {
    let nilai = [10, 20, 30];
    let mut i = 0;

    while i < nilai.len() {
        println!("nilai[{i}] = {}", nilai[i]);
        i += 1;
    }
}
CodeTEXT
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.

RSRUST
fn main() {
    let mut angka = 1;
    while angka <= 10 {
        if angka == 4 {
            println!("berhenti di {angka}");
            break;
        }
        angka += 1;
    }
}
CodeTEXT
berhenti di 4

continue berguna untuk melewati nilai yang tidak perlu diproses:

RSRUST
fn main() {
    let mut n = 0;
    while n < 6 {
        n += 1;
        if n % 2 == 0 {
            continue;
        }
        println!("ganjil: {n}");
    }
}
CodeTEXT
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:

RSRUST
fn main() {
    let mut coba = 0;
    while true {
        coba += 1;
        if coba == 2 {
            break;
        }
    }
    println!("percobaan: {coba}");
}
CodeTEXT
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:

RSRUST
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:

RSRUST
fn main() {
    let hasil = loop {
        break 42;
    };
    println!("hasil = {hasil}");
}
CodeTEXT
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.

RSRUST
fn main() {
    let mut n: u8 = 255;
    while n <= 255 {
        println!("{n}");
        n += 1;
    }
}
CodeTEXT
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:

CodeTEXT
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.

KebutuhanBentuk yang tepat
jumlah putaran sudah diketahuifor dengan rentang
berhenti saat kondisi tertentuwhile
berhenti sambil mengembalikan nilailoop dengan break bernilai
membaca seluruh elemen koleksifor 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

  1. The Rust Programming Language. Control Flow, Repetition with Loops.
  2. The Rust Reference. Loop expressions.
  3. Standard library. Keyword while.
  4. Standard library. Keyword loop.
  5. The rustc book. Warn-by-default lints, while_true.