07 枚举与模式匹配

枚举值

使用枚举中的变体创建实例：

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

【注】枚举的全部变体全部在其标识符的命名空间中，并且使用::将标识符与变体分隔开。

定义一个参数是枚举的函数来接收枚举的变体，并调用这个函数：

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

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

fn route(ip_kind: IpAddrKind) {
    //执行过程
}

另外，枚举允许我们直接将其关联的数据嵌入枚举变体内，下面将IPv4和IPv6分别变体关联上一个String值：

fn main() {
    enum IpAddr {
        V4(String),
        V6(String),
    }

    let home = IpAddr::V4(String::from("127.0.0.1"));

    let loopback = IpAddr::V6(String::from("::1"));
}

以上代码可以看出枚举的变体实际上是一个接收一个String参数返回枚举实例的函数，即这些构造函数会自动被定义。

枚举相比与结构体的一大优势是：每个变体可以拥有不同类型和数量的关联数据。还是以ip地址为例，IPv4 的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。如果我们想要将 V4 地址存储为四个 u8 值而 V6 地址仍然表现为一个 String，此时结构体无法实现这一场景。枚举则可以轻易的处理：

fn main() {
    enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
    }

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

实际上，Rust已经为IP地址提供了一套可以开箱即用的定义，它采用了定义v4和v6两个独立的结构体，并且作为自定义枚举变体的关联数据，定义形式如下：

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}
}

这里给到我们一个知识点：枚举的变体中可以嵌入任意类型的数据，无论是字符串、数字类型、还是结构体，甚至是另外一个枚举。

【注意】没有将标准库中的定义引入作用域时，即使标准库中已经包含一个 IpAddr 的定义，仍然可以创建和使用我们自己的定义而不会有冲突。

再举一个枚举的例子，它的变体内嵌入了各种数据类型：

enum Message {
    Quit,//无关联数据
    Move { x: i32, y: i32 },//包含了一个匿名结构体
    Write(String),//包含了一个String
    ChangeColor(i32, i32, i32),//包含了3个i32类型的值
}

下面是用结构体创建类似的形式：

struct QuitMessage; // 类单元结构体，空结构体
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // 元组结构体
struct ChangeColorMessage(i32, i32, i32); // 元组结构体

这两种实现方式的区别在于，若使用结构体，每个结构体都是一种类型，我们无法轻易地定义出一个可以统一处理这些类型数据的函数，但是枚举可以，因为枚举是一个单独的类型。

当然，枚举和结构体还有一点相似的地方：我们可以像定义结构体的方法那样，定义枚举的方法：

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

方法体使用了 self 来获取调用方法的值。这个例子中，创建了一个值为Message::Write(String::from("hello"))的变量 m，而且这就是当m.call()运行时 call 方法中的 self 的值。

Option枚举

这里，Option类型描述了一种 值可能不存在的情况（类似于null，空指针），在有空值的语言中，变量总是这两种状态之一：空值和非空值。如果尝试想使用非空值一样使用空值，就会触发某种错误（如：java中的空指针异常），在Rust中，空值（Null）本身就是一个值，它是有意义的：空值是一个因为某种原因目前无效或缺失的值，也可以换句话说，Rust中没有空值的概念。不过却提供了相似盖概念的枚举，以此标识一个值无效或缺失，这个枚举就是Option<T>，它的定义如下：

enum Option<T> {
    None,//表示无效值或缺失值
    Some(T),//正常值
}

Option<T>枚举是常用的，因此它也被包含在了预导入模块中，即不需要显式地将它引入作用域。此外，它的变体也可以直接使用，而不需要加Option::前缀。（T是泛型）

使用Option值包含数值类型和字符串类型方法如下：

fn main() {
    let some_number = Some(5);
    let some_char = Some('e');

    let absent_number: Option<i32> = None;
}

当使用None变体时，必须明确指定Option<T>的具体类型，单独的None和持有数据的Some不一样，编译器无法推导出值的完整类型；当使用Some变体时，我们可以确定值时一定存在的，而且被Some持有。简而言之，因为 Option<T> 和 T（这里 T 可以是任何类型）是不同的类型，编译器不允许像一个肯定有效的值那样使用 Option<T>，例如尝试将i8类型的值与Option<i8>类型的值相加：

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

    let sum = x + y;
}

错误信息意味着 Rust 不知道该如何将 Option<i8> 与 i8 相加，因为它们的类型不同。当在 Rust 中拥有一个像 i8 这样类型的值时，编译器可以确保我们所持有的值是有效的，无需在使用之前进行空值检查。而当我们持有的数据类型是 Option<T>时，就要考虑值不存在的情况，编译器会迫使我们在使用值之前做处理。面对 Option<T>中存在的正常的 T，在进行运算前我们必须将其转换成 T。

如果我们需要持有的值可能为空值，就必须要显式地将其放入对应类型的 Option<T>中，当使用这个值时，也必须显式地处理值为空的情况。也就是说，如果一个值不是 Option<T>类型的，我们就可以认为这个值一定是非空的。

当持有 Option<T>中非空类型Some变体，如何将其中的T值取出？ 针对不同的场景Rust提供了很多 Option<T>枚举方法。(07-1 Option<T>枚举方法)

总的来说，为了使用 Option<T> 值，需要编写处理每个成员的代码。你想要一些代码只当拥有 Some(T) 值时运行，允许这些代码使用其中的 T。也希望一些代码在值为 None 时运行，这些代码并没有一个可用的 T 值。match 表达式就是这么一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。

match 控制流结构

Rust 有一个叫做 match 的极为强大的控制流运算符，它允许将一个值与一系列的模式相比较，并根据相匹配的模式执行相应代码。模式可由字面量、变量、通配符和许多其他内容构成（类似于java中的switch）。match 的能力不仅来自模式丰富的表达力，也来自编译器的安全检查，编译器确保所有可能的情况都会得到处理。

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

match 控制流按顺序匹配各个模式，如果匹配失败，就继续进行下一个模式的匹配，直至符合当前模式，并且执行关联的代码，模式与代码用=>连接，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,
    }
}

绑定值的模式

匹配分支还可以绑定被匹配对象的部分值，也是从枚举变体中取值的方法。

举例：修改上面的枚举变体来存放数据。在1999年-2008年之间，美国在25美分硬币的一侧为50个州采用了不同的设计，其他硬币则没有这种设计，如何将这个信息体现在枚举中。

#[derive(Debug)]
enum UsState {
    aaa,
    bbb,
    //.etc
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter（UsState）,
}

如何打印25美分上面的50个州某一个州的名字？

#[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,
        //增加一个state变量。当匹配到 Coin::Quarter 时，
        //变量 state 将会绑定 25 美分硬币所对应州的值。接着在分支代码中使用 state
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);
            25
        }
    }
}

fn main() {
    value_in_cents(Coin::Quarter(UsState::Alaska));
}

调用value_in_cents(Coin::Quarter(UsState::Alaska))，coin 将是Coin::Quarter(UsState::Alaska)。当将值与每个分支相比较时，没有分支会匹配，直到遇到Coin::Quarter(state)。这时，state 绑定的将会是值UsState::Alaska。接着就可以在 println! 表达式中使用这个绑定了，像这样就可以获取 Coin 枚举的 Quarter 成员中内部的州的值。

匹配 Option<T>

如果想要使用Option<T>类型并且从Some中取出内部的T值，我们就可以像操作Coin枚举使用match来处理Option<T>。比如我们需要编写一个接收Option<i32>的函数，如果值存在，则将这个值+1；如果这个值不存在，则不进行任何操作。

fn plus_one(v: Option<i32>) -> Option<i32> {
    match v {
        None => None,
        Some(t) => Some(t + 1),
    }
}


fn main() {
    let five = Some(5);
    let none = None;
    println!("result is {:?}",plus_one(five));
    println!("result is {:?}",plus_one(none));
}

匹配 Some(T)

在上面的代码中，当调用plus_one(five)时，即plus_one()签名中参数值是Some(5)，match会对每个分支进行匹配比较。

None => None,

与分支不匹配，则进行下一个分支的匹配。

Some(t) => Some(t+1),

匹配成功，t 绑定了 Some 中包含的值，所以 t 的值是 5。接着匹配分支的代码被执行，所以我们将 t 的值加一并返回一个含有值 6 的新 Some，即Some(6)。

同理，当调用plus_one(none)时，plus_one()参数值是None，进行匹配， None => None,，匹配成功，因为没有进行任何代码操作，所以直接返回None。

【注意】匹配必须穷举所有可能

通配符 _

在一些匹配中，我们可能只需要一部分特定值执行不同操作，其他的值执行默认操作，我们就可以通过使用通配符_来表示剩下的所有可能的值，要注意的是，通配符分支必须放在最后，同时如果操作代码块中只有一个空元组()，即表示这个分支什么操作都不会发生。

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

    fn add_fancy_hat() {}
    fn remove_fancy_hat() {}
}

if let 简单控制流

if let语法可以让我们一种不那么冗长的方式结合使用if和let，来处理只要匹配一种模式，而无需关心其他模式的情形。例如：

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

如果值是 Some，我们希望打印出 Some 成员中的值，这个值被绑定到模式中的 max 变量里。对于 None 值我们不希望做任何操作。为了满足 match 表达式（穷尽性）的要求，必须在处理完这唯一的成员后加上 _ => ()，这显得十分多余。

此时我们就可以用if let以一种更简短的方式编写：

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

if let 语法获取通过=分隔的一个模式和一个表达式。它的工作方式与 match 相同，这里的表达式对应 match 中的输入，而表达式则对应第一个分支。在这个例子中，模式是 Some(max)，max 绑定为 Some 中的值。接着可以在 if let 代码块中使用 max 了，就跟在对应的 match 分支中一样。模式不匹配时 if let 块中的代码不会执行。

使用 if let 意味着编写更少代码，更少的缩进和更少的模板代码。但是，这样也就表示放弃了match 强制要求的穷尽性检查。match 和 if let 之间的选择取决特定的场景，这是一个在代码简洁度和穷尽性检查的权衡取舍。换句话说，可以认为 if let 是 match 的一个语法糖，它当值匹配某一模式时执行代码而忽略所有其他值。

我们还可以在 if let 中搭配使用 else 。else块中的代码与match中_分支关联的代码功能一致，也就是下面的两段代码在功能上是等同的。

使用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;
    }

总结

我们可以利用枚举创建拥有多种类型值的自定义类型，可以利用Option<T>避免所谓的空值，使用 match 或 if let 选择控制流结构进行模式匹配。