Foundation

BAB 9: Seleksi Kondisi, if, else if, else

Seleksi kondisi di Rust: if, else if, else sebagai ekspresi yang menghasilkan nilai, syarat kondisi bool, serta kesalahan cabang yang tipenya berbeda.

Di banyak bahasa, if adalah pernyataan yang tidak menghasilkan nilai, dan nilai bersyarat diambil lewat operator terpisah seperti ?:. Di Rust, if adalah ekspresi, sehingga hasilnya bisa langsung disimpan ke variabel tanpa operator tambahan.

Bab ini membahas if, else if, dan else beserta akibat dari sifat ekspresi itu: kedua cabang wajib bertipe sama, cabang yang hilang mengubah tipe hasil, dan tanda kurung di sekitar kondisi justru memunculkan peringatan. Semua contoh dikompilasi dan dijalankan dengan rustc 1.100.0.

Bentuk dasar if

RSRUST
fn main() {
    let angka = 7;

    if angka < 5 {
        println!("kurang dari lima");
    } else if angka == 5 {
        println!("tepat lima");
    } else {
        println!("lebih dari lima");
    }
}
CodeTEXT
lebih dari lima

Kondisi diperiksa dari atas ke bawah. Blok pertama yang kondisinya true dijalankan, dan sisanya dilewati. else menangani keadaan yang tidak tercakup cabang sebelumnya.

Kondisi harus bool

Rust tidak menganggap angka 0 sebagai salah atau angka lain sebagai benar. Kondisi wajib bertipe bool:

RSRUST
fn main() {
    let x = 1;
    if x {
        println!("bukan bool");
    }
}
CodeTEXT
error[E0308]: mismatched types
 --> if_bukanbool.rs:3:8
  |
3 |     if x {
  |        ^ expected `bool`, found integer

Perbaikannya menulis perbandingan yang eksplisit, misalnya if x != 0. Aturan ini menghilangkan seluruh kelas kesalahan yang muncul dari konversi diam-diam.

if sebagai ekspresi

Karena if menghasilkan nilai, hasilnya bisa langsung disimpan:

RSRUST
fn main() {
    let angka = 7;
    let status = if angka % 2 == 0 { "genap" } else { "ganjil" };
    println!("{angka} adalah {status}");
}
CodeTEXT
7 adalah ganjil

Perhatikan bahwa blok if dan else pada contoh itu tidak diakhiri titik koma, karena masing-masing menghasilkan nilai yang dipakai. Titik koma baru ditulis di akhir baris let, tempat nilai itu disimpan.

Bentuk ini menggantikan operator ternary yang tidak ada di Rust. Alih-alih kondisi ? a : b, kode Rust menulis if kondisi { a } else { b }.

Kedua cabang wajib bertipe sama

Karena if menghasilkan 1 nilai, tipe dari semua cabangnya harus sama:

RSRUST
fn main() {
    let angka = 5;
    let hasil = if angka > 3 { 10 } else { "kecil" };
    println!("{hasil}");
}
CodeTEXT
error[E0308]: `if` and `else` have incompatible types
 --> if_beda.rs:3:44
  |
3 |     let hasil = if angka > 3 { 10 } else { "kecil" };
  |                                --          ^^^^^^^ expected integer, found `&str`
  |                                |
  |                                expected because of this

Kompilator menunjuk cabang pertama sebagai acuan tipe, lalu menolak cabang lain yang berbeda. Perbaikannya menyamakan tipe, misalnya mengubah 10 menjadi "10" atau mengubah "kecil" menjadi angka.

if tanpa else

Kalau if dipakai sebagai nilai, cabang else wajib ada. Tanpa itu, hasilnya bertipe (), dan menyimpannya ke variabel yang diharapkan berisi angka ditolak:

RSRUST
fn main() {
    let angka = 5;
    let hasil = if angka > 3 { 10 };
    println!("{hasil}");
}
CodeTEXT
error[E0317]: `if` may be missing an `else` clause
 --> if_tanpa_else.rs:3:17
  |
3 |     let hasil = if angka > 3 { 10 };
  |                 ^^^^^^^^^^^^^^^--^^
  |                 |              |
  |                 |              found here
  |                 expected integer, found `()`
  |
  = note: `if` expressions without `else` evaluate to `()`

Catatan di bagian bawah pesan itu menjelaskan sebabnya: if tanpa else menghasilkan (). Kalau if hanya dipakai untuk menjalankan perintah tanpa menyimpan nilai, tidak ada masalah, dan else tidak diperlukan.

Tanda kurung di sekitar kondisi

Tanda kurung boleh ditulis, tetapi memunculkan peringatan karena tidak diperlukan:

RSRUST
fn main() {
    let x = 1;
    if (x == 1) {
        println!("pakai kurung");
    }
}
CodeTEXT
warning: unnecessary parentheses around `if` condition
 --> if_kurung.rs:3:8
  |
3 |     if (x == 1) {
  |        ^      ^

Menulis if x == 1 { menghasilkan hal yang sama tanpa peringatan. Kebiasaan dari bahasa lain yang selalu memberi kurung sebaiknya ditinggalkan saat menulis Rust.

Beberapa cabang dengan hasil berbeda

Rantai else if bisa menghasilkan nilai yang sama tipenya dari beberapa kemungkinan:

RSRUST
fn main() {
    let nilai = 85;
    let huruf = if nilai >= 90 {
        'A'
    } else if nilai >= 80 {
        'B'
    } else {
        'C'
    };
    println!("nilai {nilai} mendapat huruf {huruf}");
}
CodeTEXT
nilai 85 mendapat huruf B

Semua cabang menghasilkan char, sehingga hasilnya bisa disimpan di 1 variabel. Kalau salah satu cabang menghasilkan tipe lain, kompilasi ditolak seperti pada contoh sebelumnya.

Urutan cabang menentukan hasil

Kondisi diperiksa berurutan, dan cabang pertama yang benar dipakai. Karena itu urutan dari yang paling ketat ke yang paling longgar:

RSRUST
fn main() {
    let nilai = 95;

    let salah_urutan = if nilai >= 60 { "lulus" } else if nilai >= 90 { "sangat baik" } else { "cukup" };
    let benar_urutan = if nilai >= 90 { "sangat baik" } else if nilai >= 60 { "lulus" } else { "cukup" };

    println!("{salah_urutan} vs {benar_urutan}");
}
CodeTEXT
lulus vs sangat baik

Pada urutan pertama, nilai 95 sudah memenuhi nilai >= 60, sehingga cabang berikutnya tidak pernah dievaluasi. Kesalahan urutan seperti ini lolos kompilasi karena semuanya sah secara tipe, dan hanya terlihat dari hasil yang tidak sesuai harapan.

Menggabungkan kondisi dan if bersarang

Dua kondisi bisa digabung dengan && dan ||, sehingga tidak perlu if bertingkat untuk kasus sederhana:

RSRUST
fn main() {
    let umur = 20;
    let punya_tiket = true;

    if umur >= 18 && punya_tiket {
        println!("boleh masuk");
    } else {
        println!("tidak boleh masuk");
    }
}
CodeTEXT
boleh masuk

Kalau pemeriksaannya memang bertahap, if bersarang lebih mudah dibaca daripada 1 kondisi panjang:

RSRUST
fn main() {
    let nilai = 72;

    if nilai >= 60 {
        if nilai >= 85 {
            println!("lulus dengan pujian");
        } else {
            println!("lulus");
        }
    } else {
        println!("belum lulus");
    }
}
CodeTEXT
lulus

Bandingkan dengan rantai else if pada bagian sebelumnya: keduanya bisa menghasilkan keputusan yang sama, dan pilihan bentuknya bergantung pada apakah tahapannya perlu dipisahkan atau bisa digabung dalam 1 kondisi.

Ringkasan

if di Rust adalah ekspresi, sehingga hasilnya bisa disimpan ke variabel tanpa operator ternary. Kondisi wajib bertipe bool, dan semua cabang yang menghasilkan nilai harus bertipe sama.

if tanpa else bertipe (), sehingga tidak bisa dipakai sebagai nilai yang diharapkan berisi tipe lain. Tanda kurung di sekitar kondisi tidak diperlukan dan memunculkan peringatan, sedangkan urutan cabang else if menentukan hasil akhir karena hanya cabang pertama yang benar dijalankan.

Latihan

  1. Tulis rantai if yang mengubah nilai angka menjadi huruf A, B, C, dan D, lalu uji dengan 4 nilai berbeda.
  2. Simpan hasil if ke variabel tanpa cabang else, lalu baca pesan E0317 yang muncul.
  3. Ubah salah satu cabang menjadi tipe &str sehingga memunculkan E0308, lalu perbaiki dengan menyamakan tipenya.
  4. Tulis kondisi dengan tanda kurung, kompilasi, dan baca peringatan unnecessary parentheses.

Referensi

  1. The Rust Programming Language. Control Flow, if expressions.
  2. The Rust Reference. If expressions.
  3. The Rust Reference. Operator expressions.