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 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}"),
        _ => (),
    }
}
Listing 6-6: Sebuah match yang hanya peduli mengeksekusi kode ketika nilainya Some

Jika 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}");
    }
}
Listing 6-7: Memeriksa apakah sebuah negara sudah ada pada tahun 1900 dengan kondisi bersarang di dalam sebuah if let

Cara 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}");
    }
}
Listing 6-8: Memakai if let untuk menghasilkan sebuah nilai atau mengembalikan lebih awal

Ini 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}");
    }
}
Listing 6-9: Memakai let...else untuk memperjelas alur melalui fungsi

Perhatikan 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.