While di Rust

Perulangan (loop) while terus berjalan selama sebuah kondisi tetap true. Ini alat yang pas kalau kamu tahu apa yang sedang kamu tunggu, meskipun kamu tidak tahu persis berapa kali perulangannya akan berjalan.

Perulangan while dasar

fn main() {
    let mut count = 1;

    while count <= 5 {
        println!("{count}");
        count += 1;
    }
}

Output:

▶ Coba sendiri

Kondisinya (count <= 5) dicek sebelum setiap putaran. Begitu kondisinya false, perulangan berhenti. Di sini, itu terjadi setelah count menjadi 6.

while vs loop

Kamu bisa menulis hal yang sama dengan loop ditambah if/break manual, tapi while menyampaikan maksudmu dengan lebih langsung: “terus jalan selama ini benar.” Simpan loop untuk kasus ketika kondisi berhentinya tidak cocok diletakkan di awal perulangan.

// dengan while — jelas dan langsung ke inti
let mut n = 0;
while n < 3 {
    println!("{n}");
    n += 1;
}

// hal yang sama dengan loop — jalan, tapi lebih banyak yang harus dibaca
let mut n = 0;
loop {
    if n >= 3 {
        break;
    }
    println!("{n}");
    n += 1;
}

Contoh yang lebih nyata

while sering dipakai untuk hal seperti menunggu sebuah nilai mencapai target:

fn main() {
    let mut balance = 100;

    while balance < 200 {
        balance += 25;
        println!("Saldo sekarang {balance}");
    }

    println!("Target tercapai!");
}

Output:

Saldo sekarang 125
Saldo sekarang 150
Saldo sekarang 175
Saldo sekarang 200
Target tercapai!

▶ Coba sendiri

Kondisinya boleh berupa ekspresi apa saja yang menghasilkan bool, jadi kamu bisa menggabungkan beberapa pengecekan dengan && dan || dari halaman Operator, misalnya while balance < 200 && months < 12.

Rust tidak punya do-while

Beberapa bahasa punya perulangan do { ... } while (condition). Perulangan ini menjalankan isinya dulu, baru mengecek kondisinya, sehingga isinya selalu berjalan minimal sekali. Rust tidak punya bentuk ini. Sebagai gantinya, kamu memakai loop dan meletakkan pengecekannya di akhir.

Berikut contoh kasus yang membuat hal ini penting. Untuk menghitung jumlah digit sebuah angka, kamu bisa terus membaginya dengan 10 sampai tidak ada yang tersisa. Tapi angka 0 tetap punya satu digit, dan perulangan while biasa tidak pernah berjalan untuk angka itu:

fn main() {
    let number = 0;

    // while mengecek dulu, jadi tidak pernah berjalan untuk 0.
    let mut n = number;
    let mut digits = 0;
    while n > 0 {
        digits += 1;
        n /= 10;
    }
    println!("menurut while, {number} punya {digits} digit");

    // loop + pengecekan di akhir menjalankan isinya minimal sekali.
    let mut n = number;
    let mut digits = 0;
    loop {
        digits += 1;
        n /= 10;
        if n == 0 {
            break;
        }
    }
    println!("menurut loop, {number} punya {digits} digit");
}

Output:

menurut while, 0 punya 0 digit
menurut loop, 0 punya 1 digit

▶ Coba sendiri

Ubah number menjadi 4096, dan kedua versi akan sepakat: 4 digit. Perbedaannya hanya muncul kalau kondisinya sudah false sejak awal. Jadi patokannya: kalau isi perulangan harus berjalan minimal sekali, tulis loop dengan if ... { break; } di bagian bawah.

Masih ada satu jenis perulangan while lagi, yaitu while let, yang terus berjalan selama sebuah nilai cocok dengan sebuah pola (pattern). Ini dibahas di halaman If Let dan While Let.

Latihan

1. Jumlahkan sampai lewat 100

Jumlahkan 1 + 2 + 3 + … dan berhenti begitu totalnya lebih dari 100. Cetak berapa banyak angka yang sudah kamu jumlahkan dan totalnya. Petunjuk: kamu butuh dua variabel mut, satu untuk angka berikutnya dan satu untuk total.

Lihat solusi

fn main() {
    let mut next = 1;
    let mut total = 0;

    while total <= 100 {
        total += next;
        next += 1;
    }

    println!("Sudah menjumlahkan {} angka, totalnya {total}", next - 1);
}

Output:

Sudah menjumlahkan 14 angka, totalnya 105

▶ Coba sendiri

Setelah putaran terakhir, next sudah maju satu langkah, makanya kita mencetak next - 1. Detail “selisih satu” (off-by-one) seperti ini layak dicek dengan contoh kecil di kepala.

2. Bagi dua sampai mencapai 1

Mulai dari 1000. Selama angkanya lebih besar dari 1, bagi dengan 2 (pembagian bilangan bulat) lalu cetak. Di akhir, cetak berapa kali pembagian yang dibutuhkan. Petunjuk: n /= 2 membagi n dengan 2 dan membuang sisanya.

Lihat solusi

fn main() {
    let mut n = 1000;
    let mut steps = 0;

    while n > 1 {
        n /= 2;
        steps += 1;
        println!("{n}");
    }

    println!("Butuh {steps} kali bagi dua untuk mencapai 1");
}

Output:

500
250
125
62
31
15
7
3
1
Butuh 9 kali bagi dua untuk mencapai 1

▶ Coba sendiri

125 / 2 hasilnya 62, bukan 62.5, karena kedua angkanya bilangan bulat. Itulah yang membuat perulangan ini berhenti tepat di 1.

Ringkasan

while condition { ... } mengulang selama kondisinya true, dan kondisi dicek sebelum setiap putaran.
Pastikan ada sesuatu di dalam perulangan yang akhirnya membuat kondisinya false, kalau tidak perulangannya berjalan selamanya.
Pilih while daripada loop kalau kondisi berhentinya cocok dibaca sebagai “selama X berlaku”.
Rust tidak punya do-while. Kalau isi perulangan harus berjalan minimal sekali, pakai loop dengan pengecekan break di akhir.

Kuis singkat

1. Apa kesalahan klasik yang membuat perulangan while berjalan tanpa akhir?

2. Menurut halaman ini, kapan sebaiknya kamu memilih while daripada loop?

3. Bagaimana cara menulis perulangan yang isinya selalu berjalan minimal sekali?

Skor: 0 / 3

Bacaan lebih lanjut

Conditional Loops with while — The Rust Book (bahasa Inggris): pengenalan resmi yang membandingkan while dengan loop.
while — Rust by Example (bahasa Inggris): FizzBuzz yang bisa dijalankan, ditulis dengan perulangan while.
Predicate loops — The Rust Reference (bahasa Inggris): aturan persis tentang cara perulangan while berjalan.
Keyword while — dokumentasi standard library (bahasa Inggris): ringkasan singkat while dan while let, lengkap dengan contoh.