07 枚举与模式匹配

07 枚举与模式匹配

------正文内容展示,开始汲取新知识啦------

枚举类型,简称枚举(enums),枚举允许我们通过列举可能的值( 成员-variants) 来定义一个类型。其中一个特别有用的枚举,叫做 Option,它代表一个值要么是某个值要么什么都不是。枚举通常结合match表达式使用模式匹配,来根据不同的枚举值执行不同的代码。

枚举的定义

假设需要对IP地址进行处理,目前被广泛使用的两个主要 IP 标准:IPv4和 IPv6。处理这两种情形,只需处理将所有可能的值列举出来,这也是枚举的由来。

任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的,而且不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景,因为枚举值只可能是变体中的一个成员。

enum IpAddrKind {
    V4,
    V6,
}

每一个枚举值称为枚举的变体。

枚举值

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

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

错误信息意味着 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语法可以让我们一种不那么冗长的方式结合使用iflet,来处理只要匹配一种模式,而无需关心其他模式的情形。例如:

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 选择控制流结构进行模式匹配。

温馨提示:本文最后更新于2024-05-04 11:00:32,某些文章具有时效性,若有错误或已失效,请在下方留言或QQ联系站长
------正文内容展示,开始汲取新知识啦------

感谢您的访问,Ctrl+D收藏本站吧。

© 版权声明
THE END
喜欢就支持一下吧
点赞6赞赏 分享
评论 抢沙发
头像
良言一句三冬暖,恶语伤人六月寒。(禁止发送无意义评论)
提交
头像

昵称

夸夸TA
夸夸
还有吗!没看够!
取消
昵称表情代码图片

    暂无评论内容