Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Alur Kontrol

Kemampuan menjalankan kode tertentu tergantung pada apakah sebuah kondisi bernilai true, serta kemampuan menjalankan kode berulang selama kondisi itu true, adalah blok dasar di hampir semua bahasa pemrograman. Konstruksi yang paling umum untuk mengontrol alur eksekusi kode Rust adalah ekspresi if dan loop.

Ekspresi if

Ekspresi if memungkinkan kamu bercabang dalam kode tergantung pada kondisi tertentu. Kamu menyediakan sebuah kondisi, lalu menyatakan, “Jika kondisi ini terpenuhi, jalankan blok kode ini. Jika kondisi tidak terpenuhi, jangan jalankan blok kode ini.”

Buat proyek baru bernama branches di direktori projects kamu untuk mengeksplorasi ekspresi if. Di file src/main.rs, masukkan kode berikut:

Filename: src/main.rs

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

Semua ekspresi if diawali dengan keyword if, diikuti sebuah kondisi. Pada kasus ini, kondisinya memeriksa apakah variabel number bernilai kurang dari 5. Blok kode yang dieksekusi jika kondisi bernilai true kita letakkan tepat setelah kondisi, di dalam kurung kurawal. Blok kode yang terkait dengan kondisi pada ekspresi if kadang disebut arms, sama seperti arm pada ekspresi match yang kita bahas di bagian “Membandingkan Tebakan dengan Angka Rahasia” di Bab 2.

Secara opsional, kita juga bisa menyertakan ekspresi else—yang memang kita pilih di sini—untuk memberi program blok kode alternatif yang dieksekusi jika kondisi bernilai false. Jika kamu tidak menyertakan ekspresi else dan kondisinya false, program akan melewati blok if dan lanjut ke kode berikutnya.

Coba jalankan kode ini; kamu akan melihat output berikut:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was true

Mari kita ubah nilai number menjadi nilai yang membuat kondisinya false untuk melihat apa yang terjadi:

fn main() {
    let number = 7;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

Jalankan program lagi, dan lihat outputnya:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was false

Perlu diperhatikan juga bahwa kondisi pada kode ini harus berupa bool. Jika kondisinya bukan bool, kita akan mendapatkan error. Sebagai contoh, coba jalankan kode berikut:

Filename: src/main.rs

fn main() {
    let number = 3;

    if number {
        println!("number was three");
    }
}

Kali ini kondisi if bernilai 3, dan Rust melempar error:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: mismatched types
 --> src/main.rs:4:8
  |
4 |     if number {
  |        ^^^^^^ expected `bool`, found integer

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` (bin "branches") due to 1 previous error

Error tersebut menunjukkan bahwa Rust mengharapkan bool tetapi menerima sebuah integer. Berbeda dengan bahasa seperti Ruby dan JavaScript, Rust tidak akan mencoba mengonversi tipe non-Boolean menjadi Boolean secara otomatis. Kamu harus eksplisit dan selalu memberikan if sebuah Boolean sebagai kondisinya. Misalnya, jika kita ingin blok kode if hanya dijalankan ketika sebuah angka tidak sama dengan 0, kita bisa mengubah ekspresi if menjadi berikut:

Filename: src/main.rs

fn main() {
    let number = 3;

    if number != 0 {
        println!("number was something other than zero");
    }
}

Menjalankan kode ini akan mencetak number was something other than zero.

Menangani Beberapa Kondisi dengan else if

Kamu bisa menggunakan beberapa kondisi dengan menggabungkan if dan else dalam ekspresi else if. Sebagai contoh:

Filename: src/main.rs

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

Program ini punya empat kemungkinan jalur eksekusi. Setelah menjalankannya, kamu akan melihat output berikut:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
number is divisible by 3

Saat program ini dieksekusi, program memeriksa setiap ekspresi if bergantian, lalu mengeksekusi body pertama yang kondisinya bernilai true. Perhatikan bahwa meskipun 6 habis dibagi 2, kita tidak melihat output number is divisible by 2, juga tidak melihat teks number is not divisible by 4, 3, or 2 dari blok else. Itu karena Rust hanya mengeksekusi blok untuk kondisi true pertama yang ditemukan; setelah menemukannya, Rust tidak lagi memeriksa sisanya.

Terlalu banyak ekspresi else if bisa membuat kode kamu berantakan, jadi kalau punya lebih dari satu, sebaiknya refactor kode kamu. Bab 6 menjelaskan konstruksi bercabang Rust yang kuat bernama match untuk kasus seperti ini.

Menggunakan if dalam Statement let

Karena if adalah ekspresi, kita bisa menggunakannya di sisi kanan sebuah statement let untuk menetapkan hasilnya ke sebuah variabel, seperti pada Listing 3-2.

Filename: src/main.rs
fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}
Listing 3-2: Menetapkan hasil ekspresi if ke sebuah variabel

Variabel number akan terikat ke sebuah nilai berdasarkan hasil ekspresi if. Jalankan kode ini untuk melihat apa yang terjadi:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/branches`
The value of number is: 5

Ingat bahwa sebuah blok kode bernilai berupa ekspresi terakhir di dalamnya, dan angka pun juga merupakan ekspresi. Pada kasus ini, nilai dari seluruh ekspresi if tergantung pada blok kode mana yang dieksekusi. Artinya, nilai-nilai yang berpotensi menjadi hasil dari setiap arm pada if harus bertipe sama; pada Listing 3-2, hasil arm if dan arm else sama-sama integer i32. Jika tipenya tidak cocok, seperti pada contoh berikut, kita akan mendapatkan error:

Filename: src/main.rs

fn main() {
    let condition = true;

    let number = if condition { 5 } else { "six" };

    println!("The value of number is: {number}");
}

Ketika kita mencoba mengompilasi kode ini, kita akan mendapatkan error. Arm if dan else bertipe nilai yang tidak kompatibel, dan Rust menunjukkan dengan tepat di mana masalahnya berada dalam program:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:44
  |
4 |     let number = if condition { 5 } else { "six" };
  |                                 -          ^^^^^ expected integer, found `&str`
  |                                 |
  |                                 expected because of this

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` (bin "branches") due to 1 previous error

Ekspresi di blok if bernilai sebuah integer, sedangkan ekspresi di blok else bernilai sebuah string. Ini tidak akan bekerja, karena sebuah variabel harus bertipe tunggal, dan Rust perlu mengetahui secara pasti saat kompilasi tipe apa yang dimiliki variabel number. Dengan mengetahui tipe number, compiler bisa memverifikasi bahwa tipe itu valid di setiap tempat kita menggunakannya. Rust tidak akan bisa melakukan itu jika tipe number hanya ditentukan saat runtime; compiler akan menjadi lebih rumit dan memberikan jaminan yang lebih sedikit tentang kode jika harus melacak banyak tipe hipotetis untuk setiap variabel.

Pengulangan dengan Loop

Sering kali berguna untuk mengeksekusi sebuah blok kode lebih dari sekali. Untuk tugas ini, Rust menyediakan beberapa loop, yang akan menjalankan kode di dalam loop body sampai akhir, lalu langsung mulai lagi dari awal. Untuk bereksperimen dengan loop, mari kita buat proyek baru bernama loops.

Rust punya tiga jenis loop: loop, while, dan for. Mari kita coba satu per satu.

Mengulang Kode dengan loop

Keyword loop memberi tahu Rust untuk mengeksekusi sebuah blok kode berulang-ulang, entah selamanya atau sampai kamu secara eksplisit menyuruhnya berhenti.

Sebagai contoh, ubah file src/main.rs di direktori loops kamu menjadi seperti berikut:

Filename: src/main.rs

fn main() {
    loop {
        println!("again!");
    }
}

Saat kita menjalankan program ini, kita akan melihat again! tercetak terus-menerus sampai kita menghentikan program secara manual. Sebagian besar terminal mendukung shortcut keyboard ctrl-C untuk memutus program yang terjebak dalam loop tanpa henti. Coba saja:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/loops`
again!
again!
again!
again!
^Cagain!

Simbol ^C menunjukkan posisi di mana kamu menekan ctrl-C.

Kamu mungkin melihat, mungkin juga tidak, kata again! tercetak setelah ^C, tergantung pada posisi kode dalam loop saat menerima sinyal interrupt.

Untungnya, Rust juga menyediakan cara untuk keluar dari loop menggunakan kode. Kamu bisa menempatkan keyword break di dalam loop untuk memberi tahu program kapan harus berhenti mengeksekusi loop. Ingat bahwa kita melakukan ini dalam permainan tebak-tebakan di bagian “Keluar Setelah Tebakan yang Benar” di Bab 2 untuk keluar dari program saat pengguna memenangkan permainan dengan menebak angka yang benar.

Kita juga menggunakan continue dalam permainan tebak-tebakan; dalam loop, continue memberi tahu program untuk melewati sisa kode pada iterasi loop ini dan lanjut ke iterasi berikutnya.

Mengembalikan Nilai dari Loop

Salah satu kegunaan loop adalah mencoba ulang operasi yang kamu tahu mungkin gagal, seperti memeriksa apakah sebuah thread sudah menyelesaikan tugasnya. Kamu mungkin juga perlu mengeluarkan hasil operasi itu dari loop agar bisa dipakai oleh sisa kode kamu. Untuk melakukannya, tambahkan nilai yang ingin kamu kembalikan setelah ekspresi break yang kamu gunakan untuk menghentikan loop; nilai itu akan dikembalikan keluar dari loop sehingga kamu bisa menggunakannya, seperti ini:

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {result}");
}

Sebelum loop, kita mendeklarasikan variabel bernama counter dan menginisialisasinya dengan 0. Lalu, kita mendeklarasikan variabel bernama result untuk menyimpan nilai yang dikembalikan dari loop. Pada setiap iterasi loop, kita menambahkan 1 ke variabel counter, lalu memeriksa apakah counter sama dengan 10. Jika ya, kita menggunakan keyword break dengan nilai counter * 2. Setelah loop, kita menggunakan titik koma untuk mengakhiri statement yang menetapkan nilai ke result. Terakhir, kita mencetak nilai dalam result, yang pada kasus ini adalah 20.

Kamu juga bisa return dari dalam loop. break hanya keluar dari loop saat ini, sedangkan return selalu keluar dari fungsi saat ini.

Membedakan dengan Loop Label

Jika kamu punya loop di dalam loop, break dan continue berlaku untuk loop terdalam pada titik itu. Kamu bisa secara opsional memberi loop label pada sebuah loop, lalu menggunakannya bersama break atau continue untuk menentukan bahwa keyword itu berlaku pada loop berlabel tersebut, bukan loop terdalam. Loop label harus diawali kutip satu. Berikut contohnya dengan dua loop bersarang:

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }

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

Loop luar punya label 'counting_up, dan akan menghitung naik dari 0 ke 2. Loop dalam tanpa label menghitung turun dari 10 ke 9. break pertama yang tidak menyebut label hanya akan keluar dari loop dalam. Statement break 'counting_up; akan keluar dari loop luar. Kode ini mencetak:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.58s
     Running `target/debug/loops`
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2

Menyederhanakan Loop Kondisional dengan while

Sering kali sebuah program perlu mengevaluasi sebuah kondisi di dalam loop. Selama kondisi bernilai true, loop berjalan. Ketika kondisi tidak lagi true, program memanggil break dan menghentikan loop. Perilaku seperti ini bisa diimplementasikan dengan menggabungkan loop, if, else, dan break; kamu boleh mencobanya sekarang dalam sebuah program kalau mau. Namun, pola ini begitu umum sehingga Rust punya konstruksi bawaan dalam bahasanya untuk ini, yaitu loop while. Pada Listing 3-3, kita menggunakan while untuk menjalankan program tiga kali dengan hitungan mundur setiap kali, lalu setelah loop, mencetak sebuah pesan dan keluar.

Filename: src/main.rs
fn main() {
    let mut number = 3;

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

        number -= 1;
    }

    println!("LIFTOFF!!!");
}
Listing 3-3: Menggunakan loop while untuk menjalankan kode selama kondisi bernilai true

Konstruksi ini menghilangkan banyak nesting yang akan diperlukan jika kamu memakai loop, if, else, dan break, dan hasilnya lebih jelas. Selama kondisi bernilai true, kode berjalan; jika tidak, kode keluar dari loop.

Mengulang Melalui Koleksi dengan for

Kamu bisa memilih memakai konstruksi while untuk mengulang elemen-elemen sebuah koleksi, seperti array. Sebagai contoh, loop pada Listing 3-4 mencetak setiap elemen dalam array a.

Filename: src/main.rs
fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index += 1;
    }
}
Listing 3-4: Mengulang setiap elemen sebuah koleksi menggunakan loop while

Di sini, kode menghitung naik melalui elemen-elemen dalam array. Kode mulai dari indeks 0, lalu berloop sampai mencapai indeks terakhir dalam array (yaitu, ketika index < 5 tidak lagi true). Menjalankan kode ini akan mencetak setiap elemen dalam array:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.32s
     Running `target/debug/loops`
the value is: 10
the value is: 20
the value is: 30
the value is: 40
the value is: 50

Kelima nilai array muncul di terminal, sesuai harapan. Meskipun index akan mencapai nilai 5 pada suatu saat, loop berhenti mengeksekusi sebelum sempat mengambil nilai keenam dari array.

Namun, pendekatan ini rawan error; kita bisa membuat program panic jika nilai indeks atau kondisi ujinya salah. Sebagai contoh, jika kamu mengubah definisi array a menjadi empat elemen tetapi lupa memperbarui kondisinya menjadi while index < 4, kode akan panic. Pendekatan ini juga lambat, karena compiler menambahkan kode runtime untuk melakukan pengecekan kondisional apakah indeks masih dalam batas array pada setiap iterasi loop.

Sebagai alternatif yang lebih ringkas, kamu bisa memakai loop for dan mengeksekusi kode untuk setiap item dalam sebuah koleksi. Loop for terlihat seperti kode pada Listing 3-5.

Filename: src/main.rs
fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}
Listing 3-5: Mengulang setiap elemen sebuah koleksi menggunakan loop for

Saat kita menjalankan kode ini, kita akan melihat output yang sama seperti pada Listing 3-4. Lebih penting lagi, kita kini meningkatkan keamanan kode dan menghilangkan kemungkinan bug yang muncul karena melewati akhir array atau berhenti terlalu cepat sehingga melewatkan beberapa item. Kode mesin yang dihasilkan loop for juga bisa lebih efisien karena indeks tidak perlu dibandingkan dengan panjang array pada setiap iterasi.

Dengan loop for, kamu tidak perlu ingat mengubah kode lain jika mengubah jumlah nilai dalam array, seperti yang harus kamu lakukan dengan metode pada Listing 3-4.

Sifat aman dan ringkas loop for menjadikannya konstruksi loop yang paling umum dipakai di Rust. Bahkan dalam situasi di mana kamu ingin menjalankan kode tertentu sejumlah kali, seperti contoh hitungan mundur dengan loop while pada Listing 3-3, kebanyakan Rustacean akan memakai loop for. Caranya adalah dengan memakai Range yang disediakan standard library, yang menghasilkan semua angka berurutan mulai dari satu angka dan berhenti sebelum angka lain.

Begini tampilan hitungan mundur tersebut menggunakan loop for dan metode lain yang belum kita bahas, rev, untuk membalik range:

Filename: src/main.rs

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

Kode ini sedikit lebih rapi, bukan?

Ringkasan

Kamu berhasil! Ini bab yang cukup besar: kamu sudah belajar tentang variabel, tipe data skalar dan komposit, fungsi, komentar, ekspresi if, dan loop! Untuk mempraktikkan konsep yang dibahas di bab ini, coba buat program untuk melakukan hal berikut:

  • Mengonversi suhu antara Fahrenheit dan Celsius.
  • Menghasilkan bilangan Fibonacci ke-n.
  • Mencetak lirik lagu Natal “The Twelve Days of Christmas,” dengan memanfaatkan pengulangan dalam lagu itu.

Kalau kamu siap lanjut, kita akan membahas konsep Rust yang tidak umum ada di bahasa pemrograman lain: ownership.