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.
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}");
}
match dengan cabang yang memperkenalkan variabel baru yang menutupi variabel y yang sudah adaMari 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.
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);
}
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.
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);
}
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.
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})");
}
}
}
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.
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}");
}
}
}
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}");
}
_ => (),
}
}
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.
fn foo(_: i32, y: i32) {
println!("This code only uses the y parameter: {y}");
}
fn main() {
foo(3, 4);
}
_ dalam tanda tangan fungsiKode 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:?}");
}
Some ketika kita tidak perlu memakai nilai di dalam SomeKode 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}");
}
}
}
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.
fn main() {
let _x = 5;
let y = 10;
}
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:?}");
}
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:?}");
}
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}"),
}
}
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.
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, .., last) => {
println!("Some numbers: {first}, {last}");
}
}
}
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.
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(.., second, ..) => {
println!("Some numbers: {second}")
},
}
}
.. dengan cara yang ambiguSaat 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 => (),
}
}
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.
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}");
}
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"),
}
}
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}"),
}
}
@ untuk mengikat nilai dalam pattern sembari mengujinyaContoh 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.