【Rust】第七节：枚举与模式匹配

0 前言

是我的一点学习笔记，因为本身内容就不多、不复杂，所以这一篇内容结构与原文基本一致，但是是我个人理解原文的一个思路过程的记录。

枚举，enums，如果你了解ts、python、c/cpp、java那你可能会觉得很熟悉，但是又很不同，rust的枚举更丰富、更灵活、更方便、更强大。
所以你准备走进rust的枚举类型了吗？

原文链接：Rust程序设计语言

---

1 枚举

rust有两种枚举，一个是enum，一个是option，我们一个一个来看。

1.1 enum

以IPv4和IPv6为例

// 以下是伪代码，不可直接运行
// 1 定义enum
enum IpAddrKind {
    V4,
    V6,
}
// 2 实例化enum
let four = IpAddrKind::V4;
let six = IpAddrKind::V6;
// 3 函数可以以enum为入参
fn route(ip_type: IpAddrKind) { }
// 4 使用函数
route(IpAddrKind::V4);
route(IpAddrKind::V6);

以上是最简单的写法，那么在此之上，我们是否可以将enum与struct结合起来，从而实现更加复杂的enum类型呢？显然是可以的

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"),
};

而事实上，我们没有必要把枚举作为结构体的一部分，而是可以直接给枚举成员赋值，就像下面这样

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

而更加有趣的是，enum可以存储不同的类型！比如像这样

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

实际上，标准库也提供了一个开箱即用的定义，让我们来看看学习一下——

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

既然enum能存储不同的类型，那自然也能存储不同的struct，这种方式大大地拓展了enum的灵活性和可用性
还有更有趣的！在上一节中，我们说了struct可以使用impl，同样的，enum也能使用imple，这意味着你能实现这样的效果——

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}
impl Message {
    fn call(&self) {
        // 在这里定义方法体
    }
}
let m = Message::Write(String::from("hello"));
m.call();

1.2 option

option是rust提供的另一种枚举值，为什么要option？是为了解决空值（null）问题。
你可能在其他语言的开发中，经常遇到空值引起的各种问题。而rust中，没有空值，所以不会有空值问题。
但是rust提供了一个可以编码存在或不存在的概念的枚举，这是如何实现的呢？让我们看看标准库——

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

1、这里的是泛型语法，你可能在别的语言中已经接触过了，这里先不展开。
2、Some就是，存在一个值；None，就是并没有一个有效的值，与空值起到同样的作用。
3、Option和是不同的类型！所以他们不允许像对一个有效的那样处理Option，也就避免了问题。
是不是听起来有点拗口？让我们看看这个例子

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

let sum = x + y;// 编译器报错

是的，通过此种方式，避免了我们把一个无效的值当成一个有效的值去处理，所以我们可以安全地处理值，并且信赖他绝对不会是空值！而且，在你处理这个值时，需要显式地生命当他为空值的时候的处理方式。
于是乎，通过这种有效值、无效值的枚举方式，实现了使用、判断等场景下的安全性。
这里提到了“判断”，接下来我们就要讲match表达式了。

---

2 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, // 必须穷尽所有的可能的处理
    }
}

是不是有点像c/cpp的switch语法？让我们问问chatgpt吧，他说：
1、强大的模式匹配：match支持强大的模式匹配包括结构体、枚举、引用等等；
2、更好的安全性：match必须处理所有可能的情况；
3、更好的表达能力：match可以返回值

好的，那让我们继续看看这些神奇的点吧
模式匹配，还有一个功能就是可以绑定匹配的模式的部分值，也就是可以从枚举成员中，提取出值来使用

#[derive(Debug)] // 这样可以立刻看到州的名称
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}
enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}
fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => { // 增加state变量 
            println!("State quarter from {:?}!", state);
            25
        } // 像这样，就可以获取coin的quarter成员中的，内部的值
    }
}

上面说的，都是enum，不要忘了我们的option哦，通过match模式的必须穷举处理的特性，避免了遗漏空值处理场景的编码问题

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);

另外，还有统配模式与_占位符可以使用，要注意的是，other意味着你需要使用这个变量值，而如果不需要变量值你可以使用_

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

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() {}

---

3 if let

if let是更简单的控制流，没有什么好说的，直接看代码就行，比如以下两种方式，效果是相同的——

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

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