Loops

Dengan menggunakan loops (perulangan), Anda bisa memberitahukan Rust untuk terus-menerus melakukan sesuatu sampai Anda menginginkannya untuk berhenti. Anda menggunakan loop untuk memulai perulangan yang tidak akan berhenti, kecuali Anda memberitahukannya kapan untuk berhenti menggunakan break.

fn main() { // Program ini tidak akan pernah berhenti
    loop {

    }
}

Jadi, kita beritahukan compiler kapan ia harus berhenti.

fn main() {
    let mut counter = 0; // inisialisasi nilai counternya menjadi 0
    loop {
        counter +=1; // tambahakan value counter dengan 1
        println!("The counter is now: {}", counter);
        if counter == 5 { // hentikan perulangan saat counter == 5
            break;
        }
    }
}

Hasilnya adalah sebagai berikut:

The counter is now: 1
The counter is now: 2
The counter is now: 3
The counter is now: 4
The counter is now: 5

Jika Anda memiliki loop di dalam loop, Anda bisa memberikan mereka nama. Dengan menggunakan nama, kita bisa memberitahukan Rust loop yang mana yang inign kita break. Gunakan ' ("tick") dan sebuah : untuk memberikannya nama:

fn main() {
    let mut counter = 0;
    let mut counter2 = 0;
    println!("Now entering the first loop.");

    'first_loop: loop {
        // Berikan nama kepada loop yang pertama
        counter += 1;
        println!("The counter is now: {}", counter);
        if counter > 9 {
            // Buat loop kedua di dalam loop ini
            println!("Now entering the second loop.");

            'second_loop: loop {
                // sekarang kita berada pada 'second_loop
                println!("The second counter is now: {}", counter2);
                counter2 += 1;
                if counter2 == 3 {
                    break 'first_loop; // Hentikan 'first_loop sehingga kita bisa keluar dari program
                }
            }
        }
    }
}

Hasilnya adalah:

Now entering the first loop.
The counter is now: 1
The counter is now: 2
The counter is now: 3
The counter is now: 4
The counter is now: 5
The counter is now: 6
The counter is now: 7
The counter is now: 8
The counter is now: 9
The counter is now: 10
Now entering the second loop.
The second counter is now: 0
The second counter is now: 1
The second counter is now: 2

Loop while adalah loop yang terus-menerus melakukan sesuatu selama kondisinya true. Setiap loop, Rust akan memeriksa apakah kondisinya masih true. jika kondisinya menjadi false, Rust akan menghentikan loopnya.

fn main() {
    let mut counter = 0;

    while counter < 5 {
        counter +=1;
        println!("The counter is now: {}", counter);
    }
}

Loop for mempersilahkan Anda untuk memberitahu Rust apa yang harus dilakukan setiap saat. Pada loop for, loop akan berhenti setelah selesai mengulang dari suatu angka sampai dengan angka tertentu. Loop for sering menggunakan ranges (jarak). Anda menggunakan .. dan ..= untuk membuat rangenya.

.. akan membuat exclusive range: 0..3 creates 0, 1, 2.
..= akan membuat inclusive range: 0..=3 = 0, 1, 2, 3.

fn main() {
    for number in 0..3 {
        println!("The number is: {}", number);
    }

    for number in 0..=3 {
        println!("The next number is: {}", number);
    }
}

Hasilnya adalah:

The number is: 0
The number is: 1
The number is: 2
The next number is: 0
The next number is: 1
The next number is: 2
The next number is: 3

Perhatikan juga bahwa number menjadi nama variabel untuk 0..3. Kita bisa menyebutnya sebagai n, atau i_loop, atau apapun. Bahkan kita bisa menggunakan nama tersebut di dalam println!.

Jika Anda tidak memerlukan nama variabel, gunakan _.

fn main() {
    for _ in 0..3 {
        println!("Printing the same thing three times");
    }
}

Ini akan mencetak:

Printing the same thing three times
Printing the same thing three times
Printing the same thing three times

_ karena kita tidak memerlukan angka untuk untuk diprint setiap saat.

Dan sebenarnya, jika Anda memberikan nama variabel dan tidak menggunakannya, Rust akan memberitahu Anda:

fn main() {
    for number in 0..3 {
        println!("Printing the same thing three times");
    }
}

Ia akan mencetak hasil yang sama seperti pada program yang sebelumnya. Rust menjalankan programnya dengan baik, akan tetapi Rust akan mengingatkan Anda bahwa Anda tidak menggunakan number:

warning: unused variable: `number`
 --> src\main.rs:2:9
  |
2 |     for number in 0..3 {
  |         ^^^^^^ help: if this is intentional, prefix it with an underscore: `_number`

Rust menyarankan Anda untuk _number daripada menuliskan _. Menulis _ di depan nama variabel berarti "mungkin nanti Saya akan membutuhkannya". Tapi kalau Anda hanya menggunakan _ artinya "Saya sama sekali tidak peduli dengan variabel ini". Jadi Anda bisa menambahkan _ di depan nama variabel jika mungkin Anda akan menggunakannya kemudian dan tidak ingin compiler memberikan warning tentang itu.

Anda juga bisa menggunakan break untuk me-return value. Anda menuliskan valuenya tepat setelah break dan menggunakan ;. Ini adalah contoh loop dan break yang mengisi value ke variabel my_number.

fn main() {
    let mut counter = 5;
    let my_number = loop {
        counter +=1;
        if counter % 53 == 3 {
            break counter;
        }
    };
    println!("{}", my_number);
}

Hasilnya adalah 56. break counter; berarti "break dan kembalikan value dari variabel counter". Dan karena loop block tersebut dimulai dengan let, maka my_number diisi dengan value tersebut.

Sekarang kita tahu bagaimana caranya menggunakan loop. Tapi jangan lupa bahwa masih ada satu problem yang belum kita selesaikan pada chapter tentang match. Oleh karena itu, ini adalah solusi yang lebih baik untuk menyelesaikan problem tersebut. Kita menyebutnya solusi yang lebih baik dikarenakan kita ingin membandingkan semua warnanya, dan loop for bisa digunakan untuk keperluan itu.

fn match_colours(rbg: (i32, i32, i32)) {
    println!("Comparing a colour with {} red, {} blue, and {} green:", rbg.0, rbg.1, rbg.2);
    let new_vec = vec![(rbg.0, "red"), (rbg.1, "blue"), (rbg.2, "green")]; // Taruh warna-warna tersebut ke dalam vec, yang isinya merupakan tuple yang berisi nama warna dan nilainya
    let mut all_have_at_least_10 = true; // Kita mulai dengan true. Kita akan ubah menjadi false jika value dari warnanya di bawah 10
    for item in new_vec {
        if item.0 < 10 {
            all_have_at_least_10 = false; // Sekarang nilainya false
            println!("Not much {}.", item.1) // Dan kita cetak nama warnanya.
        }
    }
    if all_have_at_least_10 { // Periksa apakah ia masih bernilai true, jika ya, lakukan print
        println!("Each colour has at least 10.")
    }
    println!(); // Tambahkan satu line
}

fn main() {
    let first = (200, 0, 0);
    let second = (50, 50, 50);
    let third = (200, 50, 0);

    match_colours(first);
    match_colours(second);
    match_colours(third);
}

Hasilnya adalah:

Comparing a colour with 200 red, 0 blue, and 0 green:
Not much blue.
Not much green.

Comparing a colour with 50 red, 50 blue, and 50 green:
Each colour has at least 10.

Comparing a colour with 200 red, 50 blue, and 0 green:
Not much green.