Perulangan #

Perulangan atau loop adalah salah satu konsep dasar dalam pemrograman yang memungkinkan Anda untuk menjalankan blok kode berulang kali berdasarkan kondisi tertentu. Rust menyediakan beberapa mekanisme untuk melakukan perulangan, termasuk loop, while, dan for. Masing-masing memiliki kegunaan yang berbeda dan cocok untuk situasi yang berbeda pula.

loop #

loop adalah jenis perulangan paling sederhana di Rust, yang terus menjalankan blok kode berulang kali sampai Anda secara eksplisit menghentikannya. loop tidak memiliki kondisi keluar secara bawaan; Anda harus menggunakan pernyataan break untuk menghentikan perulangan.

Contoh Sederhana:

fn main() {
    let mut counter = 0;

    loop {
        counter += 1;
        println!("Counter: {}", counter);

        if counter == 10 {
            break;
        }
    }

    println!("Loop selesai.");
}

Penjelasan:

• loop akan terus berjalan tanpa batas sampai mencapai kondisi yang memicu break.
• counter ditingkatkan pada setiap iterasi, dan loop dihentikan ketika counter mencapai nilai 10.

Mengembalikan Nilai dari loop #

Anda dapat mengembalikan nilai dari loop dengan menggunakan break diikuti oleh nilai yang ingin dikembalikan.

Contoh:

fn main() {
    let result = loop {
        let mut counter = 0;

        loop {
            counter += 1;
            if counter == 5 {
                break counter * 2; // Mengembalikan nilai 10 dari loop
            }
        }
    };

    println!("Hasil dari loop: {}", result);
}

Penjelasan:

• break counter * 2 menghentikan loop dan mengembalikan nilai 10.
• Nilai tersebut disimpan dalam variabel result.

while #

while digunakan untuk melakukan perulangan selama kondisi tertentu bernilai true. Saat kondisi menjadi false, perulangan dihentikan.

Contoh:

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);

        number -= 1;
    }

    println!("Liftoff!");
}

Penjelasan:

• while memeriksa kondisi number != 0 sebelum setiap iterasi.
• Loop terus berlanjut selama number tidak sama dengan 0, dan berhenti ketika number mencapai 0.

Menggunakan while dengan Koleksi #

while sering digunakan untuk iterasi melalui koleksi dengan cara yang lebih manual.

Contoh:

fn main() {
    let mut numbers = vec![10, 20, 30, 40, 50];
    let mut index = 0;

    while index < numbers.len() {
        println!("Angka: {}", numbers[index]);
        index += 1;
    }
}

Penjelasan:

• while index < numbers.len() memastikan bahwa iterasi berhenti ketika indeks mencapai panjang vektor.
• Loop berjalan dengan menaikkan indeks untuk mengakses elemen-elemen vektor satu per satu.

for #

for adalah loop yang paling sering digunakan di Rust. for melakukan iterasi melalui elemen-elemen dalam koleksi, seperti array, vektor, atau iterator, dengan cara yang lebih aman dan lebih mudah dibaca daripada while.

Contoh Sederhana:

fn main() {
    let numbers = vec![10, 20, 30, 40, 50];

    for number in numbers {
        println!("Angka: {}", number);
    }
}

Penjelasan:

• for number in numbers iterasi melalui setiap elemen dalam vektor numbers.
• Setiap elemen number diakses secara langsung tanpa memerlukan indeks.

Iterasi dalam Rentang (Range) #

Rust menyediakan sintaks yang nyaman untuk iterasi dalam rentang angka menggunakan for dengan operator .. atau ..=.

Contoh:

fn main() {
    for i in 1..5 {
        println!("i: {}", i);
    }

    for j in 1..=5 {
        println!("j: {}", j);
    }
}

Penjelasan:

• 1..5 menghasilkan rentang dari 1 hingga 4 (tidak termasuk 5).
• 1..=5 menghasilkan rentang dari 1 hingga 5 (termasuk 5).

Iterasi dengan Indeks #

Jika Anda perlu mengakses indeks saat iterasi, Anda dapat menggunakan metode enumerate.

Contoh:

fn main() {
    let numbers = vec![10, 20, 30, 40, 50];

    for (index, number) in numbers.iter().enumerate() {
        println!("Indeks: {}, Angka: {}", index, number);
    }
}

Penjelasan:

• enumerate mengembalikan pasangan (index, value) untuk setiap elemen dalam koleksi.
• numbers.iter() menghasilkan iterator yang mengembalikan referensi ke elemen vektor, sehingga elemen tidak dipindahkan dari vektor.

Control Flow dalam Perulangan #

Rust menyediakan beberapa mekanisme kontrol alur dalam perulangan, seperti break, continue, dan label untuk loop.

break #

break digunakan untuk menghentikan loop secara paksa sebelum kondisi loop terpenuhi.

Contoh:

fn main() {
    for i in 0..10 {
        if i == 5 {
            break;
        }
        println!("i: {}", i);
    }
}

Penjelasan:

• Loop dihentikan ketika i mencapai nilai 5.

continue #

continue digunakan untuk melewati iterasi saat ini dan langsung melanjutkan ke iterasi berikutnya.

Contoh:

fn main() {
    for i in 0..10 {
        if i % 2 == 0 {
            continue; // Lewati angka genap
        }
        println!("i: {}", i);
    }
}

Penjelasan:

• continue melewati iterasi saat i genap, sehingga hanya angka ganjil yang dicetak.

Label pada Loop #

Label pada loop memungkinkan Anda untuk menentukan loop mana yang akan dihentikan ketika menggunakan break atau continue dalam nested loop (loop di dalam loop).

Contoh:

fn main() {
    'outer: for i in 0..5 {
        for j in 0..5 {
            if i == 2 && j == 2 {
                break 'outer; // Hentikan loop luar
            }
            println!("i: {}, j: {}", i, j);
        }
    }
}

Penjelasan:

• 'outer adalah label untuk loop luar.
• break 'outer menghentikan loop luar ketika kondisi terpenuhi, bukan hanya loop dalam.

Loop Infinite #

Terkadang, Anda mungkin perlu membuat loop yang berjalan terus-menerus sampai kondisi tertentu dipenuhi, seperti dalam server yang terus-menerus menunggu permintaan. Anda dapat menggunakan loop tanpa break untuk membuat loop yang berjalan terus-menerus.

Contoh:

fn main() {
    loop {
        // Lakukan sesuatu
    }
}

Penjelasan:

• Loop ini akan berjalan terus-menerus sampai program dihentikan atau break digunakan.

Perulangan dengan Iterator Kustom #

Rust memungkinkan Anda untuk membuat iterator kustom dan menggunakan for loop untuk mengiterasi item-item yang dihasilkan oleh iterator tersebut.

Contoh:

struct Counter {
    count: u32,
}

impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        self.count += 1;
        if self.count <= 5 {
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let counter = Counter::new();

    for val in counter {
        println!("Counter: {}", val);
    }
}

Penjelasan:

• Counter adalah struct sederhana dengan field count.
• Implementasi Iterator untuk Counter memungkinkan struct tersebut menghasilkan nilai berturut-turut sampai mencapai 5.
• for val in counter mengiterasi nilai yang dihasilkan oleh iterator kustom ini.

Kesimpulan #

Rust menyediakan berbagai mekanisme perulangan yang kuat dan fleksibel. Mulai dari loop sederhana dengan loop, perulangan berbasis kondisi dengan while, hingga iterasi koleksi yang lebih aman dan mudah digunakan dengan for. Dengan kontrol alur tambahan seperti break, continue, dan label loop, Anda dapat mengontrol bagaimana dan kapan perulangan harus dihentikan atau dilanjutkan. Memahami dan memanfaatkan berbagai jenis perulangan ini akan membantu Anda menulis kode Rust yang efisien dan mudah dipahami.