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
fn main() {
let angka = 7;
if angka < 5 {
println!("kurang dari lima");
} else if angka == 5 {
println!("tepat lima");
} else {
println!("lebih dari lima");
}
}
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:
fn main() {
let x = 1;
if x {
println!("bukan bool");
}
}
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:
fn main() {
let angka = 7;
let status = if angka % 2 == 0 { "genap" } else { "ganjil" };
println!("{angka} adalah {status}");
}
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:
fn main() {
let angka = 5;
let hasil = if angka > 3 { 10 } else { "kecil" };
println!("{hasil}");
}
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:
fn main() {
let angka = 5;
let hasil = if angka > 3 { 10 };
println!("{hasil}");
}
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:
fn main() {
let x = 1;
if (x == 1) {
println!("pakai kurung");
}
}
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:
fn main() {
let nilai = 85;
let huruf = if nilai >= 90 {
'A'
} else if nilai >= 80 {
'B'
} else {
'C'
};
println!("nilai {nilai} mendapat huruf {huruf}");
}
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:
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}");
}
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:
fn main() {
let umur = 20;
let punya_tiket = true;
if umur >= 18 && punya_tiket {
println!("boleh masuk");
} else {
println!("tidak boleh masuk");
}
}
boleh masuk
Kalau pemeriksaannya memang bertahap, if bersarang lebih mudah dibaca daripada 1 kondisi panjang:
fn main() {
let nilai = 72;
if nilai >= 60 {
if nilai >= 85 {
println!("lulus dengan pujian");
} else {
println!("lulus");
}
} else {
println!("belum lulus");
}
}
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
- Tulis rantai
ifyang mengubah nilai angka menjadi huruf A, B, C, dan D, lalu uji dengan 4 nilai berbeda. - Simpan hasil
ifke variabel tanpa cabangelse, lalu baca pesanE0317yang muncul. - Ubah salah satu cabang menjadi tipe
&strsehingga memunculkanE0308, lalu perbaiki dengan menyamakan tipenya. - Tulis kondisi dengan tanda kurung, kompilasi, dan baca peringatan
unnecessary parentheses.
Referensi
- The Rust Programming Language. Control Flow, if expressions.
- The Rust Reference. If expressions.
- The Rust Reference. Operator expressions.