枚举
从ip地址入手学枚举
枚举的每个成员可以处理不同类型和数量的数据
初版
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"));
第三版
使用枚举来存储两种不同 IP 地址的几种可能的选择
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),
}
其他示例
枚举实现
枚举是单独一个类型
enum Message {
Quit, // 没有关联任何数据
Move { x: i32, y: i32 }, // 包含一个匿名结构体
Write(String),
ChangeColor(i32, i32, i32),
}
结构体实现
结构体是各是各的类型
struct QuitMessage; // 类单元结构体
struct MoveMessage {
x: i32,
y: i32,
}
struct WriteMessage(String); // 元组结构体
struct ChangeColorMessage(i32, i32, i32); // 元组结构体
和结构体的相似点：在枚举上定义方法
impl Message {
fn call(&self) {
// 在这里定义方法体
}
}
let m = Message::Write(String::from("hello"));
m.call();
Option枚举
标准库定义的枚举
它编码了一个非常普遍的场景，即一个值要么有值要么没值
空值是一个因为某种原因目前无效或缺失的值
Rust 没有空值功能
空值带来的问题：像一个非空值那样使用一个空值，出现错误
Rust的设计：一个可以编码存在或不存在概念的枚举
它被包含在 prelude 之中，不需要将其显式引入作用域
它的成员也可以不需要 Option:: 前缀来直接使用 Some 和 None
// <T>是泛型
// <T> 意味着 Option 枚举的 Some 成员可以包含任意类型的数据
enum Option<T> {
Some(T),
None,
}
let some_number = Some(5);
let some_string = Some("a string");
// 如果使用 None，需要告诉 Rust Option<T> 是什么类型
// 编译器只通过 None 值无法推断出 Some 成员保存的值的类型
let absent_number: Option<i32> = None;
Option 为什么就比空值要好呢？
Option 和 T（这里 T 可以是任何类型）是不同的类型
编译器不允许像一个肯定有效的值那样使用 Option
当在 Rust 中拥有一个像 i8 这样类型的值时，编译器确保它总是有一个有效的值。可以自信使用而无需做空值检查。
只有当使用 Option（或者任何用到的类型）的时候需要担心可能没有值，而编译器会确保在使用值之前处理了为空的情况。
在对 Option 进行 T 的运算之前必须将其转换为 T，通常这能捕获到空值最常见的问题之一：假设某值不为空但实际上为空的情况
let x: i8 = 5;
let y: Option<i8> = Some(5);
let sum = x + y;
限制空值泛滥，增加 Rust 代码安全性
为了拥有一个可能为空的值，必须要显式的将其放入对应类型的 Option 中。当使用这个值时，必须明确地处理值为空的情况。
为了使用 Option 值，需要编写处理每个成员的代码。
想要一些代码只当拥有 Some(T) 值时运行，允许这些代码使用其中的 T。希望一些代码在值为 None 时运行，这些代码并没有一个可用的 T 值。
match 表达式就是这么一个处理枚举的控制流结构：
它会根据枚举的成员运行不同的代码，
这些代码可以使用匹配到的值中的数据
match 控制流运算符
将一个值与一系列的模式相比较，并根据相匹配的模式执行相应代码
模式可由字面量、变量、通配符和许多其他内容构成
示例
#[derive(Debug)] // 这样可以立刻看到州的名称
enum UsState {
Alabama,
Alaska,
// --snip--
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
// 当 match 表达式执行时，它将结果值按顺序与每一个分支的模式相比较。
// 如果模式匹配了这个值，这个模式相关联的代码将被执行。如果模式并不匹配这个值，将继续执行下一个分支
fn value_in_cents(coin: Coin) -> u8 {
// 在分支中运行多行代码，可以使用大括号
match coin {
Coin::Penny => {
println!("Lucky penny!");
1
}
Coin::Nickel => 5,
Coin::Dime => 10,
// 可以绑定匹配的模式的部分值。这也就是如何从枚举成员中提取值
// 调用 value_in_cents(Coin::Quarter(UsState::Alaska))，state 绑定的将会是值 UsState::Alaska
Coin::Quarter(state) => {
println!("State quarter from {:?}!", state);
25
}
}
}
匹配 Option
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
// 匹配是有穷的，如果下面二缺一，则编译不过，Rust 知道哪些模式被忘记了
None => None,
Some(i) => Some(i + 1),
}
}
let five = Some(5);
let six = plus_one(five); // 匹配Some(i) => Some(i + 1),
let none = plus_one(None) // 匹配None => None
通配模式
想使用通配模式获取的值
let dice_roll = 9;
match dice_roll {
// 对一些特定的值采取特殊操作，而对其他的值采取默认操作
3 => add_fancy_hat(),
7 => remove_fancy_hat(),
// 通配模式满足了 match 必须被穷尽的要求
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() {}
可以使用单元值（空元组）作为 _ 分支的代码
let dice_roll = 9;
match dice_roll {
3 => add_fancy_hat(),
7 => remove_fancy_hat(),
_ => (),
}
fn add_fancy_hat() {}
fn remove_fancy_hat() {}
简单控制流
背景
let some_u8_value = Some(0u8);
match some_u8_value {
Some(3) => println!("three"),
_ => (), // 如果只想处理 Some(3)，但是不处理其他的，则代码中太多冗余这种行
}
解决
失去 match 强制要求的穷尽性检文章来源：https://www.toymoban.com/news/detail-570115.html
if let Some(3) = some_u8_value {
println!("three");
}
// 如下两个示例等价
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;
}
总结
当枚举值包含数据时，可以根据需要处理多少情况来选择使用 match 或 if let 来获取并使用。文章来源地址https://www.toymoban.com/news/detail-570115.html
到了这里，关于rust学习-枚举和模式匹配的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
