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

Sintaksis Pattern

Di bagian ini, kita kumpulkan semua sintaksis yang valid di dalam pattern dan membahas mengapa serta kapan kamu mungkin ingin memakai masing-masing.

Mencocokkan Literal

Seperti yang kamu lihat di Bab 6, kamu bisa mencocokkan pattern langsung terhadap literal. Kode berikut memberi beberapa contoh:

fn main() {
    let x = 1;

    match x {
        1 => println!("one"),
        2 => println!("two"),
        3 => println!("three"),
        _ => println!("anything"),
    }
}

Kode ini mencetak one karena nilai di x adalah 1. Sintaksis ini berguna ketika kamu ingin kode mengambil tindakan jika ia menerima sebuah nilai konkret tertentu.

Mencocokkan Variabel Bernama

Variabel bernama adalah pattern yang tak terbantahkan (irrefutable) yang cocok dengan nilai apa pun, dan kita sudah memakainya berkali-kali dalam buku ini. Namun, ada satu kerumitan ketika kamu memakai variabel bernama di dalam ekspresi match, if let, atau while let. Karena masing-masing jenis ekspresi ini membuka scope baru, variabel yang dideklarasikan sebagai bagian dari pattern di dalam ekspresi tersebut akan menutupi (shadow) variabel bernama sama di luar konstruksi itu, seperti yang berlaku bagi semua variabel. Pada Listing 19-11, kita mendeklarasikan variabel bernama x dengan nilai Some(5) dan variabel y dengan nilai 10. Lalu kita membuat ekspresi match atas nilai x. Perhatikan pattern di cabang-cabang match dan println! di akhir, lalu coba tebak apa yang akan dicetak kode ini sebelum menjalankannya atau membaca lebih lanjut.

Filename: src/main.rs
fn main() {
    let x = Some(5);
    let y = 10;

    match x {
        Some(50) => println!("Got 50"),
        Some(y) => println!("Matched, y = {y}"),
        _ => println!("Default case, x = {x:?}"),
    }

    println!("at the end: x = {x:?}, y = {y}");
}
Listing 19-11: Sebuah ekspresi match dengan cabang yang memperkenalkan variabel baru yang menutupi variabel y yang sudah ada

Mari kita telusuri apa yang terjadi saat ekspresi match dijalankan. Pattern di cabang match pertama tidak cocok dengan nilai x yang didefinisikan, jadi kode berlanjut.

Pattern di cabang match kedua memperkenalkan variabel baru bernama y yang akan cocok dengan nilai apa pun di dalam nilai Some. Karena kita berada di scope baru di dalam ekspresi match, ini adalah variabel y yang baru, bukan y yang kita deklarasikan di awal dengan nilai 10. Binding y yang baru ini akan cocok dengan nilai apa pun di dalam Some, dan itulah yang ada di x. Karena itu, y yang baru ini terikat pada nilai dalam Some di x. Nilainya adalah 5, jadi ekspresi untuk cabang itu dijalankan dan mencetak Matched, y = 5.

Seandainya x adalah nilai None, bukan Some(5), pattern di dua cabang pertama tidak akan cocok, sehingga nilainya akan cocok dengan garis bawah. Kita tidak memperkenalkan variabel x di pattern cabang garis bawah, jadi x di ekspresi tersebut tetap x dari luar yang belum ditutupi. Dalam skenario hipotetis ini, match akan mencetak Default case, x = None.

Setelah ekspresi match selesai, scope-nya berakhir, dan begitu pula scope dari y di dalamnya. println! terakhir menghasilkan at the end: x = Some(5), y = 10.

Untuk membuat ekspresi match yang membandingkan nilai x dan y dari luar, bukan memperkenalkan variabel baru yang menutupi variabel y yang sudah ada, kita perlu memakai kondisi match guard sebagai gantinya. Kita akan membahas match guard nanti di bagian “Menambahkan Kondisi dengan Match Guards”.

Mencocokkan Beberapa Pattern

Dalam ekspresi match, kamu bisa mencocokkan beberapa pattern memakai sintaksis |, yaitu operator pattern atau (or). Misalnya, pada kode berikut, kita mencocokkan nilai x terhadap cabang-cabang match, yang pertama di antaranya punya opsi or, artinya jika nilai x cocok dengan salah satu nilai di cabang itu, kode cabang itu akan dijalankan:

fn main() {
    let x = 1;

    match x {
        1 | 2 => println!("one or two"),
        3 => println!("three"),
        _ => println!("anything"),
    }
}

Kode ini mencetak one or two.

Mencocokkan Rentang Nilai dengan ..=

Sintaksis ..= memungkinkan kita mencocokkan ke dalam rentang nilai inklusif. Pada kode berikut, ketika sebuah pattern cocok dengan nilai apa pun di dalam rentang yang diberikan, cabang itu akan dijalankan:

fn main() {
    let x = 5;

    match x {
        1..=5 => println!("one through five"),
        _ => println!("something else"),
    }
}

Jika x adalah 1, 2, 3, 4, atau 5, cabang pertama akan cocok. Sintaksis ini lebih nyaman untuk banyak nilai pencocokan daripada memakai operator | untuk menyampaikan maksud yang sama; jika kita memakai |, kita harus menulis 1 | 2 | 3 | 4 | 5. Menentukan sebuah rentang jauh lebih singkat, terutama jika kita ingin mencocokkan, misalnya, angka berapa pun antara 1 dan 1.000!

Compiler memeriksa bahwa rentang itu tidak kosong saat dikompilasi, dan karena satu-satunya tipe yang bisa diketahui Rust apakah sebuah rentang kosong atau tidak adalah char serta nilai numerik, rentang hanya diizinkan dengan nilai numerik atau char.

Berikut contoh memakai rentang nilai char:

fn main() {
    let x = 'c';

    match x {
        'a'..='j' => println!("early ASCII letter"),
        'k'..='z' => println!("late ASCII letter"),
        _ => println!("something else"),
    }
}

Rust bisa mengetahui bahwa 'c' berada di dalam rentang pattern pertama dan mencetak early ASCII letter.

Destructuring untuk Memecah Nilai

Kita juga bisa memakai pattern untuk melakukan destructure terhadap struct, enum, dan tuple agar bisa memakai bagian-bagian berbeda dari nilai tersebut. Mari kita telusuri satu per satu.

Struct

Listing 19-12 menunjukkan struct Point dengan dua field, x dan y, yang bisa kita pecah memakai sebuah pattern dengan pernyataan let.

Filename: src/main.rs
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    let Point { x: a, y: b } = p;
    assert_eq!(0, a);
    assert_eq!(7, b);
}
Listing 19-12: Melakukan destructure field struct ke dalam variabel terpisah

Kode ini membuat variabel a dan b yang cocok dengan nilai field x dan y dari struct p. Contoh ini menunjukkan bahwa nama variabel di dalam pattern tidak harus sama dengan nama field struct. Namun, lazimnya kita menyamakan nama variabel dengan nama field agar lebih mudah diingat variabel mana berasal dari field mana. Karena kebiasaan ini, dan karena menulis let Point { x: x, y: y } = p; mengandung banyak pengulangan, Rust punya singkatan untuk pattern yang cocok dengan field struct: kamu cukup mencantumkan nama field struct, dan variabel yang dibuat dari pattern akan punya nama yang sama. Listing 19-13 berperilaku sama dengan kode di Listing 19-12, tetapi variabel yang dibuat dalam pattern let adalah x dan y, bukan a dan b.

Filename: src/main.rs
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    let Point { x, y } = p;
    assert_eq!(0, x);
    assert_eq!(7, y);
}
Listing 19-13: Melakukan destructure field struct memakai singkatan field struct

Kode ini membuat variabel x dan y yang cocok dengan field x dan y dari variabel p. Hasilnya, variabel x dan y berisi nilai dari struct p.

Kita juga bisa melakukan destructure dengan nilai literal sebagai bagian dari pattern struct, alih-alih membuat variabel untuk semua field. Dengan begitu, kita bisa menguji beberapa field untuk nilai tertentu sambil membuat variabel untuk melakukan destructure pada field lainnya.

Pada Listing 19-14, kita punya ekspresi match yang memisahkan nilai Point ke dalam tiga kasus: titik yang terletak tepat di sumbu x (benar ketika y = 0), di sumbu y (x = 0), atau tidak di kedua sumbu itu.

Filename: src/main.rs
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 0, y: 7 };

    match p {
        Point { x, y: 0 } => println!("On the x axis at {x}"),
        Point { x: 0, y } => println!("On the y axis at {y}"),
        Point { x, y } => {
            println!("On neither axis: ({x}, {y})");
        }
    }
}
Listing 19-14: Melakukan destructure dan mencocokkan nilai literal dalam satu pattern

Cabang pertama akan cocok dengan titik mana pun yang terletak di sumbu x dengan menentukan bahwa field y cocok jika nilainya sama dengan literal 0. Pattern itu tetap membuat variabel x yang bisa kita pakai di kode cabang tersebut.

Demikian pula, cabang kedua cocok dengan titik mana pun di sumbu y dengan menentukan bahwa field x cocok jika nilainya 0, dan membuat variabel y untuk nilai field y. Cabang ketiga tidak menentukan literal apa pun, jadi ia cocok dengan Point lainnya dan membuat variabel untuk field x maupun y.

Pada contoh ini, nilai p cocok dengan cabang kedua karena x berisi 0, sehingga kode ini akan mencetak On the y axis at 7.

Ingat bahwa ekspresi match berhenti memeriksa cabang begitu ia menemukan pattern yang cocok pertama, jadi meskipun Point { x: 0, y: 0 } berada di sumbu x dan sumbu y, kode ini hanya akan mencetak On the x axis at 0.

Enum

Kita sudah melakukan destructure terhadap enum dalam buku ini (misalnya, Listing 6-5 di Bab 6), tetapi kita belum secara eksplisit membahas bahwa pattern untuk melakukan destructure terhadap enum sesuai dengan cara data yang tersimpan di dalam enum itu didefinisikan. Sebagai contoh, pada Listing 19-15, kita memakai enum Message dari Listing 6-2 dan menulis match dengan pattern yang akan melakukan destructure terhadap tiap nilai dalamnya.

Filename: src/main.rs
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let msg = Message::ChangeColor(0, 160, 255);

    match msg {
        Message::Quit => {
            println!("The Quit variant has no data to destructure.");
        }
        Message::Move { x, y } => {
            println!("Move in the x direction {x} and in the y direction {y}");
        }
        Message::Write(text) => {
            println!("Text message: {text}");
        }
        Message::ChangeColor(r, g, b) => {
            println!("Change color to red {r}, green {g}, and blue {b}");
        }
    }
}
Listing 19-15: Melakukan destructure varian enum yang menyimpan berbagai jenis nilai

Kode ini akan mencetak Change color to red 0, green 160, and blue 255. Coba ubah nilai msg untuk melihat kode dari cabang lain dijalankan.

Untuk varian enum yang tidak punya data sama sekali, seperti Message::Quit, kita tidak bisa melakukan destructure lebih lanjut. Kita hanya bisa mencocokkan nilai literal Message::Quit, dan tidak ada variabel dalam pattern itu.

Untuk varian enum yang menyerupai struct, seperti Message::Move, kita bisa memakai pattern yang mirip dengan pattern yang kita tulis untuk mencocokkan struct. Setelah nama varian, kita menaruh kurung kurawal lalu mencantumkan field beserta variabelnya agar kita bisa memecah bagian-bagiannya untuk dipakai di kode cabang ini. Di sini kita memakai bentuk singkat seperti di Listing 19-13.

Untuk varian enum yang menyerupai tuple, seperti Message::Write yang menyimpan tuple berisi satu elemen dan Message::ChangeColor yang menyimpan tuple berisi tiga elemen, pattern-nya mirip dengan pattern yang kita tulis untuk mencocokkan tuple. Jumlah variabel dalam pattern harus sama dengan jumlah elemen pada varian yang kita cocokkan.

Struct dan Enum Bersarang

Sejauh ini, semua contoh kita mencocokkan struct atau enum hanya satu level, tetapi pencocokan juga bisa bekerja pada item bersarang! Misalnya, kita bisa merefaktor kode di Listing 19-15 agar mendukung warna RGB dan HSV pada pesan ChangeColor, seperti yang ditunjukkan Listing 19-16.

enum Color {
    Rgb(i32, i32, i32),
    Hsv(i32, i32, i32),
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(Color),
}

fn main() {
    let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));

    match msg {
        Message::ChangeColor(Color::Rgb(r, g, b)) => {
            println!("Change color to red {r}, green {g}, and blue {b}");
        }
        Message::ChangeColor(Color::Hsv(h, s, v)) => {
            println!("Change color to hue {h}, saturation {s}, value {v}");
        }
        _ => (),
    }
}
Listing 19-16: Mencocokkan enum bersarang

Pattern pada cabang pertama dalam ekspresi match cocok dengan varian enum Message::ChangeColor yang berisi varian Color::Rgb; lalu, pattern itu mengikat ketiga nilai i32 di dalamnya. Pattern pada cabang kedua juga cocok dengan varian enum Message::ChangeColor, tetapi enum di dalamnya cocok dengan Color::Hsv sebagai gantinya. Kita bisa menentukan kondisi yang kompleks ini dalam satu ekspresi match, meskipun dua enum terlibat di sini.

Struct dan Tuple

Kita bisa mencampur, mencocokkan, dan menyarangkan pattern destructuring dengan cara yang lebih kompleks lagi. Contoh berikut menunjukkan destructure yang rumit, di mana kita menyarangkan struct dan tuple di dalam sebuah tuple lalu melakukan destructure terhadap semua nilai primitifnya:

fn main() {
    struct Point {
        x: i32,
        y: i32,
    }

    let ((feet, inches), Point { x, y }) = ((3, 10), Point { x: 3, y: -10 });
}

Kode ini memungkinkan kita memecah tipe yang kompleks menjadi bagian-bagian penyusunnya agar bisa memakai nilai yang kita minati secara terpisah.

Melakukan destructure dengan pattern adalah cara praktis untuk memakai bagian-bagian nilai, misalnya nilai dari tiap field dalam struct, secara terpisah satu sama lain.

Mengabaikan Nilai dalam Pattern

Kamu sudah melihat bahwa kadang berguna untuk mengabaikan nilai dalam pattern, misalnya pada cabang terakhir sebuah match, untuk mendapatkan penampung semua (catch-all) yang sebenarnya tidak melakukan apa pun tetapi tetap memperhitungkan semua nilai yang tersisa. Ada beberapa cara untuk mengabaikan seluruh nilai atau bagian dari nilai dalam pattern: memakai pattern _ (yang sudah kamu lihat), memakai pattern _ di dalam pattern lain, memakai nama yang diawali garis bawah, atau memakai .. untuk mengabaikan bagian nilai yang tersisa. Mari kita jelajahi cara dan alasan memakai masing-masing pattern ini.

Seluruh Nilai dengan _

Kita sudah memakai garis bawah sebagai pattern wildcard yang cocok dengan nilai apa pun tetapi tidak mengikat nilai itu. Ini sangat berguna sebagai cabang terakhir dalam ekspresi match, tetapi kita juga bisa memakainya di pattern mana pun, termasuk parameter fungsi, seperti yang ditunjukkan Listing 19-17.

Filename: src/main.rs
fn foo(_: i32, y: i32) {
    println!("This code only uses the y parameter: {y}");
}

fn main() {
    foo(3, 4);
}
Listing 19-17: Memakai _ dalam tanda tangan fungsi

Kode ini akan sepenuhnya mengabaikan nilai 3 yang dilewatkan sebagai argumen pertama, dan akan mencetak This code only uses the y parameter: 4.

Pada kebanyakan kasus, saat kamu tidak lagi membutuhkan parameter fungsi tertentu, kamu akan mengubah tanda tangannya agar tidak menyertakan parameter yang tidak terpakai itu. Mengabaikan parameter fungsi bisa sangat berguna dalam kasus-kasus seperti saat kamu mengimplementasikan trait ketika kamu memerlukan tanda tangan tipe tertentu, tetapi isi fungsi dalam implementasimu tidak membutuhkan salah satu parameternya. Dengan begitu, kamu terhindar dari peringatan compiler tentang parameter fungsi yang tidak terpakai, yang akan kamu dapatkan jika memakai sebuah nama.

Bagian dari Nilai dengan _ Bersarang

Kita juga bisa memakai _ di dalam pattern lain untuk mengabaikan hanya sebagian nilai, misalnya ketika kita ingin menguji hanya sebagian nilai tetapi tidak memerlukan bagian lainnya dalam kode yang ingin kita jalankan. Listing 19-18 menunjukkan kode yang mengelola nilai sebuah pengaturan. Kebutuhan bisnisnya adalah pengguna tidak boleh menimpa kustomisasi yang sudah ada pada sebuah pengaturan, tetapi boleh mengosongkan pengaturan itu dan memberinya nilai jika saat ini pengaturan tersebut kosong.

fn main() {
    let mut setting_value = Some(5);
    let new_setting_value = Some(10);

    match (setting_value, new_setting_value) {
        (Some(_), Some(_)) => {
            println!("Can't overwrite an existing customized value");
        }
        _ => {
            setting_value = new_setting_value;
        }
    }

    println!("setting is {setting_value:?}");
}
Listing 19-18: Memakai garis bawah di dalam pattern yang cocok dengan varian Some ketika kita tidak perlu memakai nilai di dalam Some

Kode ini akan mencetak Can't overwrite an existing customized value lalu setting is Some(5). Pada cabang match pertama, kita tidak perlu mencocokkan atau memakai nilai di salah pun varian Some, tetapi kita perlu menguji kasus ketika setting_value dan new_setting_value adalah varian Some. Dalam kasus itu, kita mencetak alasan mengapa setting_value tidak diubah, dan nilainya tidak berubah.

Pada semua kasus lain (jika setting_value atau new_setting_value adalah None) yang dinyatakan oleh pattern _ di cabang kedua, kita ingin mengizinkan new_setting_value menjadi setting_value.

Kita juga bisa memakai garis bawah di beberapa tempat dalam satu pattern untuk mengabaikan nilai-nilai tertentu. Listing 19-19 menunjukkan contoh mengabaikan nilai kedua dan keempat dalam tuple berisi lima item.

fn main() {
    let numbers = (2, 4, 8, 16, 32);

    match numbers {
        (first, _, third, _, fifth) => {
            println!("Some numbers: {first}, {third}, {fifth}");
        }
    }
}
Listing 19-19: Mengabaikan beberapa bagian dari tuple

Kode ini akan mencetak Some numbers: 2, 8, 32, dan nilai 4 serta 16 akan diabaikan.

Variabel yang Tidak Dipakai dengan Mengawali Namanya dengan _

Jika kamu membuat variabel tetapi tidak memakainya di mana pun, Rust biasanya akan mengeluarkan peringatan karena variabel yang tidak terpakai bisa jadi sebuah bug. Namun, kadang berguna untuk bisa membuat variabel yang belum akan kamu pakai, misalnya saat kamu sedang membuat prototipe atau baru memulai sebuah proyek. Dalam situasi ini, kamu bisa memberi tahu Rust agar tidak memberi peringatan tentang variabel yang tidak terpakai itu dengan mengawali nama variabelnya dengan garis bawah. Pada Listing 19-20, kita membuat dua variabel yang tidak terpakai, tetapi saat mengompilasi kode ini, kita seharusnya hanya mendapat satu peringatan untuk salah satunya.

Filename: src/main.rs
fn main() {
    let _x = 5;
    let y = 10;
}
Listing 19-20: Mengawali nama variabel dengan garis bawah untuk menghindari peringatan variabel tidak terpakai

Di sini, kita mendapat peringatan karena tidak memakai variabel y, tetapi kita tidak mendapat peringatan karena tidak memakai _x.

Perhatikan bahwa ada perbedaan halus antara memakai hanya _ dan memakai nama yang diawali garis bawah. Sintaksis _x tetap mengikat nilai ke variabel, sedangkan _ sama sekali tidak mengikat. Untuk menunjukkan kasus di mana perbedaan ini penting, Listing 19-21 akan memberi kita sebuah error.

fn main() {
    let s = Some(String::from("Hello!"));

    if let Some(_s) = s {
        println!("found a string");
    }

    println!("{s:?}");
}
Listing 19-21: Variabel tidak terpakai yang diawali garis bawah tetap mengikat nilai, yang bisa saja mengambil ownership nilai itu.

Kita akan menerima error karena nilai s tetap akan dipindahkan ke _s, yang mencegah kita memakai s lagi. Namun, memakai garis bawah sendirian tidak pernah mengikat ke nilai. Listing 19-22 akan dikompilasi tanpa error apa pun karena s tidak dipindahkan ke _.

fn main() {
    let s = Some(String::from("Hello!"));

    if let Some(_) = s {
        println!("found a string");
    }

    println!("{s:?}");
}
Listing 19-22: Memakai garis bawah tidak mengikat nilai.

Kode ini bekerja dengan baik karena kita tidak pernah mengikat s ke apa pun; nilainya tidak dipindahkan.

Bagian Nilai yang Tersisa dengan ..

Pada nilai yang punya banyak bagian, kita bisa memakai sintaksis .. untuk memakai bagian tertentu dan mengabaikan sisanya, sehingga tidak perlu mencantumkan garis bawah untuk setiap nilai yang diabaikan. Pattern .. mengabaikan bagian mana pun dari nilai yang belum kita cocokkan secara eksplisit di bagian pattern lainnya. Pada Listing 19-23, kita punya struct Point yang menyimpan koordinat dalam ruang tiga dimensi. Dalam ekspresi match, kita ingin hanya beroperasi pada koordinat x dan mengabaikan nilai pada field y dan z.

fn main() {
    struct Point {
        x: i32,
        y: i32,
        z: i32,
    }

    let origin = Point { x: 0, y: 0, z: 0 };

    match origin {
        Point { x, .. } => println!("x is {x}"),
    }
}
Listing 19-23: Mengabaikan semua field Point kecuali x dengan memakai ..

Kita mencantumkan nilai x lalu cukup menyertakan pattern ... Ini lebih cepat daripada harus menulis y: _ dan z: _, terutama ketika kita bekerja dengan struct yang punya banyak field dalam situasi yang hanya satu atau dua field yang relevan.

Sintaksis .. akan mengembang menjadi sebanyak nilai yang dibutuhkannya. Listing 19-24 menunjukkan cara memakai .. dengan tuple.

Filename: src/main.rs
fn main() {
    let numbers = (2, 4, 8, 16, 32);

    match numbers {
        (first, .., last) => {
            println!("Some numbers: {first}, {last}");
        }
    }
}
Listing 19-24: Mencocokkan hanya nilai pertama dan terakhir dalam tuple dan mengabaikan semua nilai lainnya

Pada kode ini, nilai pertama dan terakhir dicocokkan dengan first dan last. .. akan cocok dengan dan mengabaikan semua yang ada di tengah.

Namun, memakai .. harus tidak ambigu. Jika tidak jelas nilai mana yang dimaksud untuk dicocokkan dan mana yang harus diabaikan, Rust akan memberi kita error. Listing 19-25 menunjukkan contoh pemakaian .. yang ambigu, jadi kode ini tidak akan dikompilasi.

Filename: src/main.rs
fn main() {
    let numbers = (2, 4, 8, 16, 32);

    match numbers {
        (.., second, ..) => {
            println!("Some numbers: {second}")
        },
    }
}
Listing 19-25: Sebuah percobaan memakai .. dengan cara yang ambigu

Saat kita mengompilasi contoh ini, kita mendapat error ini:

$ cargo run
   Compiling patterns v0.1.0 (file:///projects/patterns)
error: `..` can only be used once per tuple pattern
 --> src/main.rs:5:22
  |
5 |         (.., second, ..) => {
  |          --          ^^ can only be used once per tuple pattern
  |          |
  |          previously used here

error: could not compile `patterns` (bin "patterns") due to 1 previous error

Mustahil bagi Rust untuk menentukan berapa banyak nilai dalam tuple yang harus diabaikan sebelum mencocokkan sebuah nilai dengan second, lalu berapa banyak nilai lagi yang harus diabaikan setelahnya. Kode ini bisa berarti kita ingin mengabaikan 2, mengikat second ke 4, lalu mengabaikan 8, 16, dan 32; atau bahwa kita ingin mengabaikan 2 dan 4, mengikat second ke 8, lalu mengabaikan 16 dan 32; dan seterusnya. Nama variabel second tidak punya arti khusus bagi Rust, jadi kita mendapat error compiler karena memakai .. di dua tempat seperti ini adalah hal yang ambigu.

Menambahkan Kondisi dengan Match Guards

Sebuah match guard adalah kondisi if tambahan, yang ditentukan setelah pattern dalam cabang match, yang juga harus cocok agar cabang itu dipilih. Match guard berguna untuk menyampaikan ide yang lebih kompleks daripada yang bisa dilakukan oleh pattern saja. Perlu dicatat, namun, bahwa match guard hanya tersedia dalam ekspresi match, bukan ekspresi if let atau while let.

Kondisi itu bisa memakai variabel yang dibuat dalam pattern. Listing 19-26 menunjukkan sebuah match yang cabang pertamanya punya pattern Some(x) dan juga punya match guard if x % 2 == 0 (yang akan bernilai true jika angkanya genap).

fn main() {
    let num = Some(4);

    match num {
        Some(x) if x % 2 == 0 => println!("The number {x} is even"),
        Some(x) => println!("The number {x} is odd"),
        None => (),
    }
}
Listing 19-26: Menambahkan match guard ke sebuah pattern

Contoh ini akan mencetak The number 4 is even. Saat num dibandingkan dengan pattern di cabang pertama, keduanya cocok karena Some(4) cocok dengan Some(x). Lalu, match guard memeriksa apakah sisa hasil bagi x dengan 2 sama dengan 0, dan karena memang sama, cabang pertama dipilih.

Seandainya num adalah Some(5), match guard di cabang pertama akan bernilai false karena sisa 5 dibagi 2 adalah 1, yang tidak sama dengan 0. Rust lalu akan lanjut ke cabang kedua, yang cocok karena cabang kedua tidak punya match guard dan karena itu cocok dengan varian Some apa pun.

Tidak ada cara untuk menyampaikan kondisi if x % 2 == 0 di dalam sebuah pattern, jadi match guard memberi kita kemampuan untuk menyatakan logika ini. Kelemahan dari ekspresivitas tambahan ini adalah compiler tidak mencoba memeriksa kehabisan (exhaustiveness) ketika ekspresi match guard terlibat.

Saat membahas Listing 19-11, kita menyebut bahwa kita bisa memakai match guard untuk menyelesaikan masalah penutupan pattern kita. Ingat bahwa kita membuat variabel baru di dalam pattern pada ekspresi match, alih-alih memakai variabel di luar match. Variabel baru itu berarti kita tidak bisa menguji nilai variabel luar. Listing 19-27 menunjukkan cara memakai match guard untuk memperbaiki masalah ini.

Filename: src/main.rs
fn main() {
    let x = Some(5);
    let y = 10;

    match x {
        Some(50) => println!("Got 50"),
        Some(n) if n == y => println!("Matched, n = {n}"),
        _ => println!("Default case, x = {x:?}"),
    }

    println!("at the end: x = {x:?}, y = {y}");
}
Listing 19-27: Memakai match guard untuk menguji kesetaraan dengan variabel luar

Kode ini sekarang akan mencetak Default case, x = Some(5). Pattern di cabang match kedua tidak memperkenalkan variabel baru y yang akan menutupi y luar, yang berarti kita bisa memakai y luar di dalam match guard. Alih-alih menentukan pattern sebagai Some(y), yang akan menutupi y luar, kita menentukan Some(n). Ini membuat variabel baru n yang tidak menutupi apa pun karena tidak ada variabel n di luar match.

Match guard if n == y bukan sebuah pattern dan karena itu tidak memperkenalkan variabel baru. y ini adalah y luar, bukan y baru yang menutupinya, dan kita bisa mencari nilai yang sama dengan y luar dengan membandingkan n dan y.

Kamu juga bisa memakai operator atau (or) | dalam match guard untuk menentukan beberapa pattern; kondisi match guard akan berlaku untuk semua pattern itu. Listing 19-28 menunjukkan prioritas saat menggabungkan pattern yang memakai | dengan match guard. Bagian penting dari contoh ini adalah match guard if y berlaku untuk 4, 5, dan 6, meskipun sekilas tampak seperti if y hanya berlaku untuk 6.

fn main() {
    let x = 4;
    let y = false;

    match x {
        4 | 5 | 6 if y => println!("yes"),
        _ => println!("no"),
    }
}
Listing 19-28: Menggabungkan beberapa pattern dengan match guard

Kondisi match menyatakan bahwa cabang hanya cocok jika nilai x sama dengan 4, 5, atau 6 dan jika y bernilai true. Saat kode ini dijalankan, pattern cabang pertama cocok karena x adalah 4, tetapi match guard if y bernilai false, jadi cabang pertama tidak dipilih. Kode lanjut ke cabang kedua, yang memang cocok, dan program ini mencetak no. Alasannya adalah kondisi if berlaku untuk seluruh pattern 4 | 5 | 6, bukan hanya nilai terakhir 6. Dengan kata lain, prioritas match guard terhadap sebuah pattern berperilaku seperti ini:

(4 | 5 | 6) if y => ...

bukan seperti ini:

4 | 5 | (6 if y) => ...

Setelah menjalankan kode, perilaku prioritas itu menjadi jelas: Seandainya match guard diterapkan hanya pada nilai terakhir dalam daftar nilai yang ditentukan memakai operator |, cabang itu akan cocok dan program akan mencetak yes.

Memakai Binding @

Operator at @ memungkinkan kita membuat variabel yang menyimpan sebuah nilai pada saat yang sama ketika kita menguji nilai itu untuk pencocokan pattern. Pada Listing 19-29, kita ingin menguji apakah field id dari Message::Hello berada dalam rentang 3..=7. Kita juga ingin mengikat nilai itu ke variabel id agar bisa memakainya di kode yang terkait dengan cabang tersebut.

fn main() {
    enum Message {
        Hello { id: i32 },
    }

    let msg = Message::Hello { id: 5 };

    match msg {
        Message::Hello { id: id @ 3..=7 } => {
            println!("Found an id in range: {id}")
        }
        Message::Hello { id: 10..=12 } => {
            println!("Found an id in another range")
        }
        Message::Hello { id } => println!("Found some other id: {id}"),
    }
}
Listing 19-29: Memakai @ untuk mengikat nilai dalam pattern sembari mengujinya

Contoh ini akan mencetak Found an id in range: 5. Dengan menentukan id @ sebelum rentang 3..=7, kita menangkap nilai apa pun yang cocok dengan rentang itu ke dalam variabel bernama id, sembari menguji bahwa nilainya memang cocok dengan pattern rentang tersebut.

Pada cabang kedua, di mana pattern hanya menentukan sebuah rentang, kode yang terkait dengan cabang itu tidak punya variabel yang berisi nilai aktual dari field id. Nilai field id bisa saja 10, 11, atau 12, tetapi kode yang mengikuti pattern itu tidak tahu mana yang benar. Kode pattern itu tidak bisa memakai nilai dari field id karena kita tidak menyimpan nilai id ke dalam variabel.

Pada cabang terakhir, di mana kita menentukan sebuah variabel tanpa rentang, kita memang punya nilai yang bisa dipakai di kode cabang dalam variabel bernama id. Alasannya adalah kita memakai sintaksis singkatan field struct. Namun, kita tidak menerapkan pengujian apa pun pada nilai field id di cabang ini, seperti yang kita lakukan di dua cabang pertama: nilai apa pun akan cocok dengan pattern ini.

Memakai @ memungkinkan kita menguji sebuah nilai dan menyimpannya dalam variabel di dalam satu pattern.

Ringkasan

Pattern Rust sangat berguna untuk membedakan berbagai jenis data. Saat dipakai dalam ekspresi match, Rust memastikan bahwa pattern-mu mencakup setiap nilai yang mungkin, atau programmu tidak akan dikompilasi. Pattern dalam pernyataan let dan parameter fungsi membuat konstruksi itu lebih berguna, memungkinkan nilai dipecah menjadi bagian-bagian lebih kecil dan bagian-bagian itu ditetapkan ke variabel. Kita bisa membuat pattern sederhana maupun kompleks sesuai kebutuhan kita.

Selanjutnya, untuk bab kedua dari akhir buku ini, kita akan melihat beberapa aspek lanjutan dari beragam fitur Rust.