Alur Kontrol Ringkas dengan if let dan let...else
Sintaks if let memungkinkan kamu menggabungkan if dan let menjadi cara yang
lebih ringkas untuk menangani nilai yang cocok dengan satu pola sementara
mengabaikan sisanya. Perhatikan program pada Listing 6-6 yang melakukan match
pada nilai Option<u8> di variabel config_max, tetapi hanya ingin mengeksekusi
kode jika nilai tersebut adalah varian Some.
fn main() {
let config_max = Some(3u8);
match config_max {
Some(max) => println!("The maximum is configured to be {max}"),
_ => (),
}
}
match yang hanya peduli mengeksekusi kode ketika nilainya SomeJika nilainya Some, kita mencetak nilai di dalam varian Some dengan
mengikat nilai tersebut ke variabel max di dalam pola. Kita tidak ingin
melakukan apa pun dengan nilai None. Untuk memenuhi ekspresi match, kita harus
menambahkan _ => () setelah memproses hanya satu varian, dan itu adalah
boilerplate yang menyebalkan untuk ditambahkan.
Sebagai gantinya, kita bisa menulisnya dengan cara yang lebih pendek memakai
if let. Kode berikut berperilaku sama dengan match di Listing 6-6:
fn main() {
let config_max = Some(3u8);
if let Some(max) = config_max {
println!("The maximum is configured to be {max}");
}
}
Sintaks if let menerima sebuah pola dan sebuah ekspresi yang dipisahkan oleh
tanda sama dengan. Cara kerjanya sama dengan match, di mana ekspresi tersebut
diberikan ke match dan polanya adalah arm pertamanya. Dalam kasus ini, polanya
adalah Some(max), dan max terikat ke nilai di dalam Some. Setelah itu kita
bisa memakai max di dalam blok if let dengan cara yang sama seperti kita
memakai max di arm match yang bersangkutan. Kode di dalam blok if let
hanya berjalan jika nilai tersebut cocok dengan pola.
Memakai if let berarti lebih sedikit mengetik, lebih sedikit indentasi, dan
lebih sedikit boilerplate. Namun, kamu kehilangan pengecekan menyeluruh yang
dipaksakan match, yang memastikan kamu tidak lupa menangani satu kasus pun.
Pilihan antara match dan if let tergantung pada apa yang sedang kamu kerjakan
dalam situasi tertentu, dan apakah keuntungan dari sisi kerapian sepadan dengan
kehilangan pengecekan menyeluruh.
Dengan kata lain, kamu bisa memperlakukan if let sebagai gula sintaks untuk
sebuah match yang menjalankan kode ketika nilai cocok dengan satu pola, lalu
mengabaikan semua nilai lainnya.
Kita bisa menambahkan else pada sebuah if let. Blok kode yang menyertai
else sama dengan blok kode yang akan menyertai kasus _ pada ekspresi match
yang setara dengan if let dan else tersebut. Ingat kembali definisi enum
Coin di Listing 6-4, di mana varian Quarter juga menyimpan sebuah nilai
UsState. Jika kita ingin menghitung semua koin selain quarter yang kita lihat
sekaligus mengumumkan negara bagi setiap quarter, kita bisa melakukannya dengan
ekspresi match seperti ini:
#[derive(Debug)]
enum UsState {
Alabama,
Alaska,
// --snip--
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn main() {
let coin = Coin::Penny;
let mut count = 0;
match coin {
Coin::Quarter(state) => println!("State quarter from {state:?}!"),
_ => count += 1,
}
}
Atau kita bisa memakai ekspresi if let dan else, seperti ini:
#[derive(Debug)]
enum UsState {
Alabama,
Alaska,
// --snip--
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn main() {
let coin = Coin::Penny;
let mut count = 0;
if let Coin::Quarter(state) = coin {
println!("State quarter from {state:?}!");
} else {
count += 1;
}
}
Tetap di “Jalur Bahagia” dengan let...else
Pola yang umum adalah melakukan sejumlah komputasi ketika sebuah nilai tersedia,
dan mengembalikan nilai default sebaliknya. Menyinggung contoh koin dengan nilai
UsState tadi, jika kita ingin mengatakan sesuatu yang lucu tergantung pada
seberapa tua negara pada quarter tersebut, kita bisa menambahkan sebuah method
pada UsState untuk memeriksa usia sebuah negara, seperti ini:
#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
Alabama,
Alaska,
// --snip--
}
impl UsState {
fn existed_in(&self, year: u16) -> bool {
match self {
UsState::Alabama => year >= 1819,
UsState::Alaska => year >= 1959,
// -- snip --
}
}
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn describe_state_quarter(coin: Coin) -> Option<String> {
if let Coin::Quarter(state) = coin {
if state.existed_in(1900) {
Some(format!("{state:?} is pretty old, for America!"))
} else {
Some(format!("{state:?} is relatively new."))
}
} else {
None
}
}
fn main() {
if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
println!("{desc}");
}
}
Lalu, kita bisa memakai if let untuk match pada jenis koin, dengan memperkenalkan
sebuah variabel state di dalam body kondisi tersebut, seperti di Listing 6-7.
#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
Alabama,
Alaska,
// --snip--
}
impl UsState {
fn existed_in(&self, year: u16) -> bool {
match self {
UsState::Alabama => year >= 1819,
UsState::Alaska => year >= 1959,
// -- snip --
}
}
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn describe_state_quarter(coin: Coin) -> Option<String> {
if let Coin::Quarter(state) = coin {
if state.existed_in(1900) {
Some(format!("{state:?} is pretty old, for America!"))
} else {
Some(format!("{state:?} is relatively new."))
}
} else {
None
}
}
fn main() {
if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
println!("{desc}");
}
}
if letCara itu sudah cukup, tetapi pekerjanya didorong ke dalam body statement
if let. Jika pekerjaan yang harus dilakukan lebih rumit, bisa jadi sulit
mengikuti bagaimana cabang-cabang di tingkat atas saling berkaitan. Kita juga
bisa memanfaatkan kenyataan bahwa ekspresi menghasilkan sebuah nilai, baik untuk
menghasilkan state dari if let maupun untuk mengembalikan lebih awal, seperti
di Listing 6-8. (Kamu juga bisa melakukan hal serupa dengan match, tentu saja.)
#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
Alabama,
Alaska,
// --snip--
}
impl UsState {
fn existed_in(&self, year: u16) -> bool {
match self {
UsState::Alabama => year >= 1819,
UsState::Alaska => year >= 1959,
// -- snip --
}
}
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn describe_state_quarter(coin: Coin) -> Option<String> {
let state = if let Coin::Quarter(state) = coin {
state
} else {
return None;
};
if state.existed_in(1900) {
Some(format!("{state:?} is pretty old, for America!"))
} else {
Some(format!("{state:?} is relatively new."))
}
}
fn main() {
if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
println!("{desc}");
}
}
if let untuk menghasilkan sebuah nilai atau mengembalikan lebih awalIni pun sedikit menyebalkan untuk diikuti dengan caranya sendiri! Satu cabang
if let menghasilkan sebuah nilai, sementara cabang lainnya mengembalikan
keluar dari fungsi sepenuhnya.
Untuk membuat pola umum ini lebih enak diekspresikan, Rust punya let...else.
Sintaks let...else menerima sebuah pola di sisi kiri dan sebuah ekspresi di
sisi kanan, sangat mirip dengan if let, tetapi tanpa cabang if, hanya ada
cabang else. Jika polanya cocok, ia akan mengikat nilai dari pola tersebut ke
scope luar. Jika polanya tidak cocok, program akan mengalir ke arm else,
yang harus mengembalikan keluar dari fungsi.
Di Listing 6-9, kamu bisa melihat bagaimana tampilan Listing 6-8 ketika memakai
let...else menggantikan if let.
#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
Alabama,
Alaska,
// --snip--
}
impl UsState {
fn existed_in(&self, year: u16) -> bool {
match self {
UsState::Alabama => year >= 1819,
UsState::Alaska => year >= 1959,
// -- snip --
}
}
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn describe_state_quarter(coin: Coin) -> Option<String> {
let Coin::Quarter(state) = coin else {
return None;
};
if state.existed_in(1900) {
Some(format!("{state:?} is pretty old, for America!"))
} else {
Some(format!("{state:?} is relatively new."))
}
}
fn main() {
if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
println!("{desc}");
}
}
let...else untuk memperjelas alur melalui fungsiPerhatikan bahwa dengan cara ini ia tetap berada di “jalur bahagia” pada body
utama fungsi, tanpa harus punya alur kontrol yang jauh berbeda untuk dua cabang
sebagaimana halnya if let.
Jika kamu menghadapi situasi di mana logika programmu terlalu panjang untuk
diekspresikan dengan match, ingatlah bahwa if let dan let...else juga ada
di kotak perkakasmu sebagai programmer Rust.
Ringkasan
Kita telah membahas cara memakai enum untuk membuat tipe kustom yang bisa menjadi
salah satu dari sekumpulan nilai berenumerasi. Kita telah menunjukkan bagaimana
tipe Option<T> dari standard library membantumu memakai sistem tipe untuk
mencegah error. Ketika nilai enum memiliki data di dalamnya, kamu bisa memakai
match atau if let untuk mengekstrak dan memakai nilai-nilai tersebut,
tergantung pada berapa banyak kasus yang perlu kamu tangani.
Program Rust-mu kini bisa mengekspresikan konsep di domainmu memakai struct dan enum. Membuat tipe kustom untuk dipakai di API-mu memastikan tipe aman: compiler akan memastikan fungsi-fungsimu hanya menerima nilai dengan tipe yang diharapkan oleh masing-masing fungsi.
Untuk menyediakan sebuah API yang tersusun rapi bagi penggunamu, mudah dipakai, dan hanya mengekspos persis apa yang mereka butuhkan, sekarang mari kita beralih ke module-module Rust.