Rust 學習筆記：枚舉與模式匹配

在本文中，首先，我們將定義和使用枚舉。接下來，我們將探討一個特別有用的枚舉，稱為 Option。然后，我們將了解 match 表達式中的模式匹配。最后，我們將介紹 if let 構造。

定義枚舉（Enum）

結構體提供了一種將相關字段和數據分組在一起的方法，而枚舉則提供了一種說明一個值是一組可能值中的一個的方法。

任何 IP 地址都可以是 IPv4 或者 IPv6，但不能同時是這兩個地址。IP 地址的這個屬性使得枚舉數據結構非常合適，因為枚舉值只能是它的一個變體。

定義 IpAddrKind 枚舉：

enum IpAddrKind {V4,V6,
}

IpAddrKind 是一個自定義數據類型。

枚舉變量

我們可以像這樣創建 IpAddrKind 的兩個變體的實例：

    let four = IpAddrKind::V4;let six = IpAddrKind::V6;

注意，枚舉的變體位于其標識符下的命名空間中，我們使用雙冒號分隔兩者。這是有用的，因為現在兩個值 IpAddrKind::V4 和 IpAddrKind::V6 都是同一類型：IpAddrKind。

我們還可以定義一個接受任意 IpAddrKind 的函數：

fn route(ip_kind: IpAddrKind) {}

我們可以用任意一個變量調用這個函數：

    route(IpAddrKind::V4);route(IpAddrKind::V6);

枚舉可以作為結構體的字段：

    enum IpAddrKind {V4,V6,}struct IpAddr {kind: IpAddrKind,address: String,}let home = IpAddr {kind: IpAddrKind::V4,address: String::from("127.0.0.1"),};let loopback = IpAddr {kind: IpAddrKind::V6,address: String::from("::1"),};

但是，僅使用枚舉表示相同的概念更為簡潔：我們可以將數據直接放入每個枚舉變體中，而不是在結構體中使用枚舉。這個枚舉的新定義表明，V4 和 V6 的實例將具有相關的 String 值：

    enum IpAddr {V4(String),V6(String),}let home = IpAddr::V4(String::from("127.0.0.1"));let loopback = IpAddr::V6(String::from("::1"));

我們直接將數據附加到枚舉的每個變體上，因此不需要額外的結構體。我們定義的每個枚舉變體的名稱也成為構造枚舉實例的函數。也就是說，IpAddr::V4() 是一個函數調用，它接受一個 String 參數并返回一個 IpAddr 類型的實例。

使用 enum 而不是 struct 還有另一個好處：每個變量可以有不同的關聯數據類型和數量。如果我們想要將 V4 地址存儲為四個 u8 值，但仍然將 V6 地址表示為一個 String 值，那么我們將無法使用結構體。枚舉可以輕松處理這種情況：

    enum IpAddr {V4(u8, u8, u8, u8),V6(String),}let home = IpAddr::V4(127, 0, 0, 1);let loopback = IpAddr::V6(String::from("::1"));

讓我們來看看標準庫是如何定義 IpAddr 的：兩個不同結構體的形式將地址數據嵌入到變量中，每個變量的定義不同。

struct Ipv4Addr {// --snip--
}struct Ipv6Addr {// --snip--
}enum IpAddr {V4(Ipv4Addr),V6(Ipv6Addr),
}

注意，即使標準庫包含了 IpAddr 的定義，我們仍然可以創建和使用我們自己的定義而不會產生沖突，因為我們沒有將標準庫的定義引入我們的作用域。

我們也可以使用 impl 在枚舉上定義方法：

    impl Message {fn call(&self) {// method body would be defined here}}let m = Message::Write(String::from("hello"));m.call();

方法的主體會使用 self 來獲取我們調用該方法的值。在這個例子中，我們創建了一個變量 m，它的值是 Message::Write(String::from(“hello”))，這就是 m.call() 運行時調用方法體中的 self 的值。

Option 枚舉及其相對于 NULL 的優勢

Option 是標準庫定義的另一個枚舉。Option 類型編碼了一種非常常見的場景，在這種場景中，值可以是什么東西，也可以是空（什么都沒有）。

Rust沒有許多其他語言所具有的 null 特性。null 是一個表示沒有值的值。在帶有 null 的語言中，變量總是處于兩種狀態之一：null 或非 null。

空值的問題是，如果嘗試將空值用作非空值，將得到某種錯誤。然而，null 試圖表達的概念仍然是有用的：null 是由于某種原因當前無效或不存在的值。

問題不在于概念，而在于具體的實現。因此，Rust 沒有空值，但它有一個枚舉，可以編碼值存在或不存在的概念。該 enum 為 Option<T>，由標準庫定義如下：

enum Option<T> {None,Some(T),
}

可以直接使用 Some 和 None，而不使用 Option:: 前綴。Some(T) 和 None 是 Option<T> 類型的變體。

<T> 語法是 Rust 的一個我們還沒有討論的特性。它是一個泛型類型參數，意味著 Option 枚舉的某些變體可以保存任何類型的數據。

示例：

    let some_number = Some(5);let some_char = Some('e');let absent_number: Option<i32> = None;

some_number 的類型為 Option<i32>，some_char 的類型是 Option<char>。對于 None，Rust 要求必須提供具體的 Option 類型。

當我們有一個 None 值時，在某種意義上它和 null 的意思是一樣的：我們沒有一個有效值。那么為什么 Option<T> 比 null 好呢？因為 Option<T> 和 T （T 可以是任何類型）是不同的類型。

例如，這段代碼無法編譯，因為它試圖將 i8 添加到 Option<i8>：

    let x: i8 = 5;let y: Option<i8> = Some(5);let sum = x + y;

Rust 不理解如何添加 i8 和 Option<i8>，因為它們是不同的類型。

須先將 Option<T> 轉換為 T，然后才能對其執行 T 操作。一般來說，這有助于抓住 null 最常見的問題之一：假設某些東西不是空的，而實際上是空的。為了擁有一個可能為空的值，必須顯式地將該值的類型設置為 Option<T>。然后，當使用該值時，需要顯式地處理該值為空的情況。只要值的類型不是 Option<T>，就可以放心地假設該值不為空。

這是 Rust 經過深思熟慮的設計決策，目的是限制 null 的普遍性，提高 Rust 代碼的安全性。

match 和枚舉

match 表達式是一個控制流結構，當與枚舉一起使用時，它就是這樣做的：它將運行不同的代碼，這取決于它擁有的枚舉的哪個變體，并且該代碼可以使用匹配值中的數據。

我們可以編寫一個函數，它接受一枚未知的美國硬幣，并以與計數機類似的方式確定它是哪一枚硬幣，并返回其以美分為單位的值：

enum Coin {Penny,Nickel,Dime,Quarter,
}fn value_in_cents(coin: Coin) -> u8 {match coin {Coin::Penny => {println!("Lucky penny!");1}Coin::Nickel => 5,Coin::Dime => 10,Coin::Quarter => 25,}
}

當匹配表達式執行時，它按順序將結果值與每個模式進行比較。如果模式匹配該值，則執行與該模式關聯的代碼。如果該模式與值不匹配，則繼續執行。

match 的的另一個有用特性是：它們可以綁定到與模式匹配的值部分。這就是從枚舉變量中提取值的方法。

作為一個例子，讓我們修改一個枚舉變量，使其包含數據。

#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {Alabama,Alaska,// --snip--
}enum Coin {Penny,Nickel,Dime,Quarter(UsState),
}

在這段代碼的匹配表達式中，我們將一個名為 state 的變量添加到匹配變量 Coin::Quarter 值的模式中。當一個 Coin::Quarter 匹配時，狀態變量將綁定到該 Quarter 的狀態值。然后我們可以在代碼中使用 state，如下所示：

fn value_in_cents(coin: Coin) -> u8 {match coin {Coin::Penny => 1,Coin::Nickel => 5,Coin::Dime => 10,Coin::Quarter(state) => {println!("State quarter from {state:?}!");25}}
}

如果我們調用 value_in_cents(Coin::Quarter(UsState::Alaska))，Coin 將是 Coin::Quarter(UsState::Alaska)。當我們將該值與每個匹配進行比較時，在到達 Coin::Quarter(state) 之前，它們都不匹配。此時，州的綁定將是值 UsState::Alaska。然后我們可以使用 println! 打印該值。

與 Option<T> 匹配

我們還可以使用 match 來處理 Option<T>。

編寫一個函數，它接受 Option<i32>，如果里面有一個值，則將該值加 1。如果里面沒有值，函數應該返回 None 值，并且不嘗試執行任何操作。

    fn plus_one(x: Option<i32>) -> Option<i32> {match x {None => None,Some(i) => Some(i + 1),}}let five = Some(5);let six = plus_one(five);let none = plus_one(None);

match 應該是詳盡的

match 中的模式必須涵蓋所有可能性。

考慮一下這個版本的 plus_one 函數：

    fn plus_one(x: Option<i32>) -> Option<i32> {match x {Some(i) => Some(i + 1),}}

報錯：error[E0004]: non-exhaustive patterns: `None` not covered。

我們沒有處理 None 的情況，所以無法編譯。

Rust 中的匹配是詳盡的：為了使代碼有效，我們必須窮盡每一種可能性。特別是在 Option<T> 的情況下，當 Rust 防止我們忘記顯式處理 None 情況時，它保護我們避免在可能為 null 的情況下假設我們有一個值。

Catch-all 模式和 _ 占位符

使用枚舉，我們還可以對一些特定的值采取特殊的操作，但對所有其他值采取默認操作。

    let dice_roll = 9;match dice_roll {3 => add_fancy_hat(),7 => remove_fancy_hat(),other => move_player(other),}fn add_fancy_hat() {}fn remove_fancy_hat() {}fn move_player(num_spaces: u8) {}

最后一個模式 other 將匹配所有沒有明確列出的值，other 必須放在最后。

當我們想要捕獲所有值，但又不想在捕獲所有值的模式中使用值時可以使用 _。這是一個特殊的模式，它匹配任何值，并且不綁定到該值。這告訴 Rust 我們不打算使用這個值，所以 Rust 不會警告我們一個未使用的變量。

    let dice_roll = 9;match dice_roll {3 => add_fancy_hat(),7 => remove_fancy_hat(),_ => reroll(),}fn add_fancy_hat() {}fn remove_fancy_hat() {}fn reroll() {}

這個例子也滿足窮竭性要求，因為我們顯式地忽略了所有的其他值。

還可以有另外一種寫法：

    let dice_roll = 9;match dice_roll {3 => add_fancy_hat(),7 => remove_fancy_hat(),_ => (),}fn add_fancy_hat() {}fn remove_fancy_hat() {}

使用 () 作為與 _ 匹配時的動作。這將告訴 Rust：不使用任何不匹配先前模式的值，并且不想在這種情況下運行任何代碼。

使用 if let 和 let else 簡化控制流

if let 語法以一種更簡潔的方式來處理匹配一個模式的值，同時忽略其他模式。

    let config_max = Some(3u8);match config_max {Some(max) => println!("The maximum is configured to be {max}"),_ => (),}

如果值是 Some，我們通過將值綁定到模式中的變量 max 來打印出 Some 變量中的值。不對 None 值做任何事情。

每次都要寫 _ => () 確實很煩，可以用 if let 語法進行簡化：

    let config_max = Some(3u8);if let Some(max) = config_max {println!("The maximum is configured to be {max}");}

if let 的語法接受一個模式和一個用等號分隔的表達式。它的工作方式與匹配相同，將表達式提供給匹配，而模式是它的第一個臂。在本例中，模式是 Some(max)，并且 max 綁定到 Some 內部的值。if let 塊中的代碼僅在值與模式匹配時運行。

使用 if let 意味著更少的輸入、更少的縮進和更少的樣板代碼。但是，失去了 match 強制執行的詳盡檢查。

換句話說，可以將 if let 視為匹配的語法糖，當值匹配一個模式時運行代碼，然后忽略所有其他值。

我們可以在 if 語句中包含 else 語句，該代碼塊相當于 if let 和 else。

match 寫法：

    let mut count = 0;match coin {Coin::Quarter(state) => println!("State quarter from {state:?}!"),_ => count += 1,}

if let…else 寫法：

    let mut count = 0;if let Coin::Quarter(state) = coin {println!("State quarter from {state:?}!");} else {count += 1;}

let else 的高階用法

let else 語法在左側接受一個模式，在右側接受一個表達式（變量），這與 if let 非常相似，但它沒有 if 分支，只有 else 分支。如果模式匹配，它將在外部作用域中綁定來自模式的值。如果模式不匹配，程序將進入 else。

一種常見的模式是當值存在時執行一些計算，否則返回默認值。

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}
}

我們還可以利用表達式生成的值來從 if let 中生成狀態或提前返回。

用 if let 來寫：

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."))}
}

用 let else 來寫，會更簡單：

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."))}
}