Loop di Rust

Rust punya tiga cara untuk mengulang kode: loop, while, dan for. Halaman ini membahas loop, yang paling sederhana dan paling langsung di antara ketiganya. loop adalah perulangan (loop) yang terus berulang selamanya sampai kamu menyuruhnya berhenti.

loop dasar

fn main() {
    let mut count = 0;

    loop {
        count += 1;
        println!("{count}");

        if count == 3 {
            break;
        }
    }
}

Output:

1
2
3

▶ Coba sendiri

loop sendiri tidak pernah berhenti. break-lah yang mengakhirinya. Tanpa if count == 3 { break; } itu, program ini akan terus menampilkan angka selamanya.

Perhatian

Setiap loop butuh jalan keluar. Kalau kamu lupa menulis break, program kamu akan macet (hang), terus menampilkan (atau mengerjakan) hal yang sama tanpa henti sampai kamu menghentikannya secara paksa.

Mengembalikan nilai dari loop

Ini sesuatu yang bisa dilakukan loop tapi tidak bisa dilakukan while dan for: kamu bisa menaruh nilai setelah break, dan nilai itu menjadi hasil dari seluruh loop:

fn main() {
    let mut count = 0;

    let result = loop {
        count += 1;
        if count == 10 {
            break count * 2; // berhenti dan kembalikan sebuah nilai
        }
    };

    println!("{result}");
}

Output:

20

▶ Coba sendiri

Ini berguna untuk hal-hal seperti “terus coba lagi sampai berhasil, lalu berikan hasilnya”. Kamu akan lebih sering melihat pola ini di kode sungguhan daripada yang kamu kira.

Perhatikan titik koma setelah } penutup loop. Seluruh loop { ... } adalah sisi kanan dari let result = ...;, jadi pernyataan let itu butuh ; di akhirnya, sama seperti let x = 5;.

Kenapa loop, bukan while true?

Kalau kamu datang dari bahasa lain, mungkin kamu terbiasa menulis perulangan tanpa akhir sebagai while true { ... }. Itu bisa jalan di Rust, tapi compiler akan memberi peringatan:

warning: denote infinite loops with `loop { ... }`
 --> src/main.rs:5:5
  |
5 |     while true {
  |     ^^^^^^^^^^ help: use `loop`

Artinya: tandai perulangan tanpa akhir dengan loop { ... }. Ini bukan sekadar soal gaya. Rust tahu bahwa isi sebuah loop selalu dijalankan, dan satu-satunya jalan keluar adalah break. Rust tidak menganggap hal yang sama untuk while true, karena Rust tidak melihat nilai kondisinya. Ini benar-benar berpengaruh saat sebuah variabel baru diisi nilainya di dalam loop:

fn main() {
    let mut n = 1;
    let answer; // belum ada nilainya

    loop {
        if n * n > 50 {
            answer = n * n; // isi tepat sebelum keluar
            break;
        }
        n += 1;
    }

    println!("Kuadrat pertama di atas 50 adalah {answer}");
}

Output:

Kuadrat pertama di atas 50 adalah 64

▶ Coba sendiri

Dengan loop, Rust bisa melihat bahwa satu-satunya cara untuk sampai ke println! adalah lewat break tersebut, jadi answer pasti sudah terisi. Ganti loop dengan while true, dan kamu akan mendapat error[E0381]: used binding answer is possibly-uninitialized (variabel answer dipakai padahal mungkin belum diisi). Compiler mengira loop itu bisa saja selesai tanpa pernah menjalankan if-nya.

Dalam praktiknya, versi paling rapi dari program ini memakai break dengan nilai, seperti yang kamu lihat di atas: let answer = loop { ... break n * n; ... };. Apa pun caranya, pelajarannya sama: kalau maksudmu “selamanya, sampai aku pakai break”, tulislah loop.

Kapan memakai loop

loop adalah pilihan yang tepat kalau kamu tidak tahu sebelumnya berapa kali kode akan diulang, karena kamu sedang menunggu suatu kondisi menjadi benar, bukan menghitung sepanjang sebuah rentang atau daftar. Untuk menghitung atau menelusuri sebuah koleksi, while dan for (dibahas berikutnya) biasanya lebih enak dibaca.

Latihan

1. Hitung mundur peluncuran

Pakai loop untuk menampilkan hitungan mundur dari 5 sampai 1, lalu tampilkan Meluncur!. Petunjuk: mulai dengan let mut n = 5;, dan pakai break begitu n mencapai 0.

Lihat solusi

fn main() {
    let mut n = 5;

    loop {
        if n == 0 {
            break;
        }
        println!("{n}...");
        n -= 1;
    }

    println!("Meluncur!");
}

Output:

5...
4...
3...
2...
1...
Meluncur!

▶ Coba sendiri

Pengecekannya ada di awal, jadi saat n bernilai 0, loop berhenti sebelum menampilkan 0....

2. Pangkat dua pertama di atas 1000

Mulai dari 1 dan terus kalikan dua. Pakai break dengan nilai untuk mendapatkan angka pertama yang lebih dari 1000, dan hitung berapa kali pengalian yang dibutuhkan. Petunjuk: simpan penghitung mut di luar loop, dan tulis let power = loop { ... };.

Lihat solusi

fn main() {
    let mut value = 1;
    let mut doublings = 0;

    let power = loop {
        value *= 2;
        doublings += 1;
        if value > 1000 {
            break value;
        }
    };

    println!("{power} setelah {doublings} kali dikali dua");
}

Output:

1024 setelah 10 kali dikali dua

▶ Coba sendiri

break value; mengakhiri loop dan memberikan value ke power. Penghitungnya ada di luar loop, jadi nilainya tetap tersimpan setelah loop selesai.

Ringkasan

• loop terus berulang selamanya sampai dihentikan oleh break. Selalu pastikan ada break-nya.
• break value; menghentikan loop dan mengembalikan value sebagai hasil dari seluruh ekspresi loop.
• Tulis loop, bukan while true: Rust tahu isi loop selalu dijalankan, dan ini membantunya mengecek variabel-variabel kamu.
• Pakai loop saat kamu mengulang “sampai suatu kondisi terjadi”, bukan saat menghitung sejumlah putaran yang sudah diketahui.

Kuis singkat

Kuis singkat

1. Apa yang menghentikan loop biasa supaya tidak berjalan selamanya?

Otomatis berhenti setelah 100 putaran Pernyataan break di dalamnya Rust mendeteksi perulangan tanpa akhir saat kompilasi

2. Apa hasil dari menulis break count * 2; di dalam sebuah loop?

Error kompilasi, karena break tidak bisa membawa nilai Hanya keluar dari loop dan mengabaikan nilainya Mengakhiri loop dan menjadikan count * 2 sebagai hasil dari seluruh ekspresi loop

3. Menurut halaman ini, kapan loop lebih tepat dipakai daripada while atau for?

Saat kamu tidak tahu sebelumnya berapa kali kode akan diulang Saat menghitung sepanjang rentang yang tetap Saat menelusuri sebuah koleksi

4. Apa yang terjadi kalau kamu menulis while true { ... } di Rust?

Error kompilasi Bisa jalan, tapi compiler memperingatkanmu untuk memakai loop Hanya berjalan tepat satu kali

Skor: 0 / 4

Bacaan lebih lanjut

• Repetition with Loops — The Rust Book (bahasa Inggris): pengenalan resmi tentang loop, while, dan for.
• Returning Values from Loops — The Rust Book (bahasa Inggris): bagian singkat tentang break dengan nilai.
• loop — Rust by Example (bahasa Inggris): contoh loop, break, dan continue yang bisa dijalankan.
• Returning from loops — Rust by Example (bahasa Inggris): satu contoh kecil lagi tentang loop yang mengembalikan nilai.
• Keyword loop — dokumentasi standard library (bahasa Inggris): referensi ringkas tentang cara loop dan break bekerja bersama.