pattern 是 rust 的特殊語法，用來匹配類別的 struct，結合 match expression 及其他 struct 可提供更多程式 control flow 的支配權。Pattern 由以下內容組成
- Literals
- Destructured arrays, enums, structs, or tuples
- Variables
- Wildcards
- Placeholders
這些元件就是要處理的 data，接著可用匹配值決定程式是否有正確的資料，運作特定部分的 code
透過一些值與 pattern 比較來使用它們，如果匹配，就做對應處理。
以下討論 pattern 適用處，refutable 與 irrefutable 模式的區別，及不同類別的 pattern 語法
所有可能用到 Pattern 的地方
match Arms
match 表達式由 match 關鍵字、用於匹配的值和一個或多個分支構成，這些分支包含一個模式和在值匹配分支的模式時運行的表達式：
match VALUE {
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
}match 表達式必須是 窮盡（exhaustive）的，所有可能的值都必須被考慮到。
有一個特定的模式 _ 可以匹配所有情況，不過它從不綁定任何變數。這在例如希望忽略任何未指定值的情況很有用。本章之後的 “在模式中忽略值” 部分會詳細介紹 _ 模式的更多細節。
Conditional if let Expression
chap6 討論過 if let 及如何撰寫只關心一個狀況的match 語法的簡寫。if let 可對應一個 optional 帶有 code 的 else，在 if let pattern 不匹配時運作。
可以組合併匹配 if let、else if 和 else if let 表達式。相比 match表達式一次只能將一個值與模式比較提供了更多靈活性；一系列 if let、else if、else if let 分支並不要求其條件相互關聯。
fn main() {
let favorite_color: Option<&str> = None;
let is_tuesday = false;
let age: Result<u8, _> = "34".parse();
if let Some(color) = favorite_color {
println!("Using your favorite color, {}, as the background", color);
} else if is_tuesday {
println!("Tuesday is green day!");
} else if let Ok(age) = age {
if age > 30 {
println!("Using purple as the background color");
} else {
println!("Using orange as the background color");
}
} else {
println!("Using blue as the background color");
}
}注意 if let 也可以像 match 分支那樣引入 shadowed 變數：if let Ok(age) = age 引入了一個新的 shadowed 變數 age，它包含 Ok 成員中的值。這意味著 if age > 30 條件需要位於這個代碼塊內部；不能將兩個條件組合為 if let Ok(age) = age && age > 30，因為我們希望與 30 進行比較的被覆蓋的 age 直到大括號開始的新作用域才是有效的。
if let 表達式的缺點在於無法用 compiler 檢查窮盡性，而 match 表達式有做檢查。如果去掉最後的 else 塊而遺漏處理一些情況，編譯器也不會警告這類可能的邏輯錯誤。
while let Conditional Loop
只要 stack.pop() 回傳 Some 就列印
let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
while let Some(top) = stack.pop() {
println!("{}", top);
}for Loop
for 可以獲取一個模式，例如在 for 循環中使用模式來解構元組
用 enumerate 方法產生一個迭代器，得到一個值和其在迭代器中的索引，他們位於一個元組中。第一個 enumerate 呼叫會產生元組 (0, 'a')。當這個值匹配模式 (index, value)，index將會是 0 而 value 將會是 'a'，並印出第一行輸出。
let v = vec!['a', 'b', 'c'];
for (index, value) in v.iter().enumerate() {
println!("{} is at index {}", value, index);
}let statement
let x = 5; 其實就是 pattern，也就是 let PATTERN = EXPRESSION;
這個模式實際上等於 “將任何值綁定到變數 x，不管值是什麼”
// 將一個 tuple 與模式匹配
let (x, y, z) = (1, 2, 3);function parameters
函數參數也可以是模式，x 部分就是一個模式
fn foo(x: i32) {
// 代碼
}ex:
fn print_coordinates(&(x, y): &(i32, i32)) {
println!("Current location: ({}, {})", x, y);
}
fn main() {
let point = (3, 5);
print_coordinates(&point);
}closure 類似 function，故也可以在 closure parameter 使用 pattern
在一些地方，模式必須是 irrefutable 的，必須匹配所提供的任何值。在另一些情況，他們則可以是 refutable 的。
Refutability: 是否 pattern 會匹配失敗
模式有兩種形式：refutable（可反駁的）和 irrefutable（不可反駁的）。能匹配任何傳遞的可能值的模式被稱為是 不可反駁的（irrefutable）。例如 let x = 5; 語句中的 x，因為 x 可以匹配任何值所以不可能會失敗。
對某些可能的值進行匹配會失敗的模式被稱為是 可反駁的（refutable）。一個這樣的例子便是 if let Some(x) = a_value 表達式中的 Some(x)；如果變量 a_value 中的值是 None 而不是 Some，那麼 Some(x) 模式不能匹配。
let 語句、 函數參數和 for 循環只能接受不可反駁的模式，因為通過不匹配的值程序無法進行有意義的工作。if let 和 while let 表達式被限制為只能接受可反駁的模式，因為根據定義就是要處理可能的失敗：條件表達式的功能就是根據成功或失敗執行不同的操作。
通常無需擔心可反駁和不可反駁模式的區別，不過確實需要熟悉可反駁性的概念，這樣當在錯誤信息中看到時就知道如何應對。遇到這些情況，根據代碼行為的意圖，需要修改模式或者使用模式的結構。
一個嘗試在 Rust 要求不可反駁模式的地方使用可反駁模式以及相反情況的例子
let Some(x) = some_option_value;會發生編譯錯誤
error[E0005]: refutable pattern in local binding: `None` not covered
-->
|
3 | let Some(x) = some_option_value;
| ^^^^^^^ pattern `None` not covered為了修復在需要不可反駁模式的地方使用可反駁模式的情況，可以修改使用模式的代碼：不同於使用 let，可以使用 if let。
if let Some(x) = some_option_value {
println!("{}", x);
}如果為 if let 提供了一個總是會匹配的模式，嘗試把不可反駁模式用到 if let 上，比如以下的 x，則會出錯：
if let x = 5 {
println!("{}", x);
};會發生編譯錯誤
error[E0162]: irrefutable if-let pattern
--> <anon>:2:8
|
2 | if let x = 5 {
| ^ irrefutable pattern匹配分支必須使用可反駁模式，除了最後一個分支需要使用能匹配任何剩餘值的不可反駁模式。
Pattern Syntax
以下列出所有 pattern 的有效語法
matching literals
let x = 1;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("anything"),
}matching named variables
Named variables 是 irrefutable（不可反駁的）可 match any value
match 會開始一個新作用域，match 表達式中作為模式的一部分聲明的變數會覆蓋 match 結構之外的同名變數，與所有變數一樣。
fn main() {
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
// y 是 shaowed variable，跟上面的 y 無關，可匹配任何 Some 裡面的 value
// 當 scope 結束，y 的作用域就結束
Some(y) => println!("Matched, y = {:?}", y),
_ => println!("Default case, x = {:?}", x),
}
// 這裡的 y 還是一樣是 10
println!("at the end: x = {:?}, y = {:?}", x, y);
}multiple patterns
在 match 表達式中，可以使用 | 語法匹配多個模式，它代表 or 的意思。
let x = 1;
match x {
// 符合 1 或 2
1 | 2 => println!("one or two"),
3 => println!("three"),
_ => println!("anything"),
}matching rangers of values with …
... 語法允許你匹配一個閉區間範圍內的值。
let x = 5;
match x {
// 如果 x 是 1、2、3、4 或 5，就會匹配
1 ... 5 => println!("one through five"),
_ => println!("something else"),
}rangers 範圍只允許用於數字或 char 值
let x = 'c';
match x {
'a' ... 'j' => println!("early ASCII letter"),
'k' ... 'z' => println!("late ASCII letter"),
_ => println!("something else"),
}destructing to break apart values
可以使用模式來解構 structs、enums、tuples 和引用，以便使用這些值的不同部分。
destructing structs
可以通過帶有模式的
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); }這個例子展示了模式中的變數名不必與結構體中的欄位一致。不過通常希望變數名與欄位名一致以便於理解變數來自於哪些欄位。
因為變數名匹配欄位名是常見的，同時因為
let Point { x: x, y: y } = p;包含了很多重複，所以對於匹配欄位的模式存在簡寫：只需列出結構體欄位的名稱，則模式產生的變數會有相同的名稱。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); }也可以在部分struct 模式中使用 literal 進行解析，而不是為所有的欄位產生變數。
fn main() { let p = Point { x: 0, y: 7 }; match p { // x 軸 Point { x, y: 0 } => println!("On the x axis at {}", x), // y 軸 Point { x: 0, y } => println!("On the y axis at {}", y), Point { x, y } => println!("On neither axis: ({}, {})", x, y), } }destructing enums
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 這樣沒有任何資料的enum，不能進一步解構其值。只能匹配其 literal Message::Quit，因此模式中沒有任何變數 Message::Quit => { println!("The Quit variant has no data to destructure.") }, // 使用大括號並列出欄位變數，以便將其分解以供此分支的代碼使用 Message::Move { x, y } => { println!( "Move in the x direction {} and in the y direction {}", x, y ); } Message::Write(text) => println!("Text message: {}", text), Message::ChangeColor(r, g, b) => { println!( "Change the color to red {}, green {}, and blue {}", r, g, b ) } } }destructing reference
當模式所匹配的值中包含引用時，需要解構引用之中的值，這可以通過在模式中指定
&做到。這讓我們得到一個包含引用所指向資料的變數，而不是包含引用的變數。這個技術在通過迭代器遍歷引用時，要使用 closure 中的值而不是其引用時非常有用。遍歷一個 vector 中的
Point實例的引用，並同時解構引用和其中的 struct 以方便對x和y值進行計算let points = vec![ Point { x: 0, y: 0 }, Point { x: 1, y: 5 }, Point { x: 10, y: -3 }, ]; let sum_of_squares: i32 = points .iter() .map(|&Point { x, y }| x * x + y * y) .sum();destructing nested structs and enums
以匹配嵌套的 enum
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 the color to red {}, green {}, and blue {}", r, g, b ) }, Message::ChangeColor(Color::Hsv(h, s, v)) => { println!( "Change the color to hue {}, saturation {}, and value {}", h, s, v ) } _ => () } }destructing nested structs and tuples
struct 和 tuple 嵌套在 tuple 中
let ((feet, inches), Point {x, y}) = ((3, 10), Point { x: 3, y: -10 });
Ignoring values in a pattern
有時忽略模式中的一些值是有用的，例如 match 中最後捕獲全部情況的分支實際上沒有做任何事，但是它確實對所有剩餘情況負責。有一些簡單的方法可以忽略模式中全部或部分值：使用 _ 模式，使用一個以下劃線開始的名稱，或者使用 ..忽略所剩部分的值。
ignoring an entire value with
__也可以用在函數的參數上fn foo(_: i32, y: i32) { println!("This code only uses the y parameter: {}", y); } fn main() { foo(3, 4); }ignoring parts of a value with a nested
_只需要測試部分值但在期望運行的代碼部分中沒有使用它們時，也可以在另一個模式內部使用
_來只忽略部分值。let mut setting_value = Some(5); let new_setting_value = Some(10); match (setting_value, new_setting_value) { // 不需要 Some 中的值時 (Some(_), Some(_)) => { println!("Can't overwrite an existing customized value"); } _ => { setting_value = new_setting_value; } }也可以在一個模式中的多處使用 underline 來忽略特定值
let numbers = (2, 4, 8, 16, 32); match numbers { (first, _, third, _, fifth) => { println!("Some numbers: {}, {}, {}", first, third, fifth) }, }ignoring an unused variable by starting its name with
_產生了一個變量卻不在任何地方使用它，Rust 會給你一個警告，因為這可能會是個 bug。但是有時是有用的，例如你正在設計原型或剛剛開始一個 project。這時你希望告訴 Rust 不要警告未使用的變量，為此可以用 underline 作為變數名的開頭。
fn main() { let _x = 5; let y = 10; }只使用
_和使用以下劃線開頭的名稱有些微妙的不同：比如_x仍會將值綁定到變數，而_則完全不會綁定。以下會得到一個編譯錯誤，因為s的值仍然會移動進_s，並阻止我們再次使用s。let s = Some(String::from("Hello!")); if let Some(_s) = s { println!("found a string"); } println!("{:?}", s);要改寫為
let s = Some(String::from("Hello!")); if let Some(_) = s { println!("found a string"); } println!("{:?}", s);ignoring remaining parts of a value with
..對於有多個部分的值，可以使用
..語法來只使用部分並忽略其它值，同時避免不得不對每一個忽略值列出下劃線。..模式會忽略模式中剩餘的任何沒有顯式匹配的值部分。以下有一個Point存放了三維空間中的坐標。在match表達式中，我們希望只操作x座標並忽略y和z的值：struct Point { x: i32, y: i32, z: i32, } let origin = Point { x: 0, y: 0, z: 0 }; match origin { // 忽略 Point 中除 x 以外的 fields Point { x, .. } => println!("x is {}", x), }fn main() { let numbers = (2, 4, 8, 16, 32); match numbers { // 只匹配 tuple 中的第一個和最後一個值並忽略掉所有其它值 (first, .., last) => { println!("Some numbers: {}, {}", first, last); }, } }如果期望匹配和忽略的值是不明確的，Rust 會給編譯錯誤。
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(.., second, ..) => {
println!("Some numbers: {}", second)
},
}
}Extra Conditionals with Match Guards
匹配守衛（match guard）是一個指定與 match 分支模式之後的額外 if 條件，它也必須被滿足才能選擇此分支。匹配守衛用於表達比單獨的模式所能允許的更為複雜的情況。
let num = Some(4);
match num {
// 判斷 x 是否 < 5
Some(x) if x < 5 => println!("less than five: {}", x),
Some(x) => println!("{}", x),
None => (),
}可以使用match guard來解決模式中 shadowed 變數的問題，那裡 match 表達式的模式中產生了一個變數而不是使用 match 之外的同名變數。新變數就代表不能夠測試外部變數的值。可使用匹配守衛修復這個問題：
fn main() {
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
// 用 matching guard 測試跟外部變數是否相等
// n == y 沒有產生新變數，這裡的 y 就是外部的 y
Some(n) if n == y => println!("Matched, n = {:?}", n),
_ => println!("Default case, x = {:?}", x),
}
println!("at the end: x = {:?}, y = {:?}", x, y);
}let x = 4;
let y = false;
match x {
// 也可以使用 或 運算符 | 來指定多個模式，同時 match guard 的條件會作用域所有的模式
4 | 5 | 6 if y => println!("yes"),
_ => println!("no"),
}@ Bindings
at （@）讓我們在產生一個存放值的變數的同時測試其值是否匹配模式。
enum Message {
Hello { id: i32 },
}
let msg = Message::Hello { id: 5 };
match msg {
// 測試 Message::Hello 的 id 字段是否位於 3...7 範圍內，同時也希望能綁定其值到 id_variable 中以便此分支相關聯的 code 可以使用它
Message::Hello { id: id_variable @ 3...7 } => {
println!("Found an id in range: {}", id_variable)
},
// 指定了一個範圍 10, 11, 12，但裡面不能使用 id，因為沒有將 id 儲存到另一個變數中
Message::Hello { id: 10...12 } => {
println!("Found an id in another range")
},
// 沒有範圍的變數
Message::Hello { id } => {
println!("Found some other id: {}", id)
},
}