文章目录

•   前言
• 1、Rust基本枚举类语法
• • 1.1、定义枚举
  • 1.2、将数据附加到枚举的变体中
  • 1.3、变体的多种嵌套方式
  • 1.4、定义枚举方法
• 2、Option枚举
• • 2.1、引入Option枚举解决控制问题
  • 2.2、枚举类的具体使用
• 3、match控制流运算符
• 4、if let 语法

  前言

  书接上文，本篇博客分享的是Rust 枚举类与模式匹配 的知识。作为安全性强的语言，Rust 的枚举类并不像其他编程语言中的概念那样简单，但依然可以十分简单的使用。

1、Rust基本枚举类语法

枚举允许我们列举所有可能的值来定义一个类型，枚举中的值也叫变体

1.1、定义枚举

我们举一个例子：

• IP地址：IPV4、IPV6

enum IpAddrKind{V4,V6}

• 接收枚举值

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

枚举的变体都位于标识符的命名空间下，使用::进行分割

1.2、将数据附加到枚举的变体中

形式如下：

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

优点：

1. 不需要额外使用struct来确定类型
2. 每个变体可以拥有不同的类型以及关联的数据量

例如：

#[derive(Debug)]enum IpAddrKind {    V4(u8,u8,u8,u8),    V6(String)}fn main() {    let home=IpAddrKind::V4(127, 0, 0, 1);    let loopback=IpAddrKind::V6(String::from("这是IPV6"));    println!("{:?}\n{:?}",home,loopback);}

运行效果：

• #[derive(Debug)]作为Rust提供的调试库是可以直接输出结构体和枚举类型的

• 但是注意占位符只能使用{:?}

• 标准库中的IpAddr

struct IpV4Addr{    //--snip--}struct IpV6Addr{    //--snip--}enum IpAddr {    V4(IpV4Addr),    V6(IpV6Addr)}

1.3、变体的多种嵌套方式

enum Message {    Quit,    Move {x:i32,y:u32},    Write(String),    ChangeColor(i32,i32,i32)}fn main() {    let q=Message::Quit;    let m=Message::Move { x: 6, y: 12 };    let w=Message::Write(String::from("hello_world"));    let c=Message::ChangeColor(255, 255, 0);}

在这段代码中枚举类变体一共有四种数据类型：

1. 不带关联数据Quit
2. 匿名结构体Move
3. 字符串类型Write
4. 匿名元组结构体ChangeColor

1.4、定义枚举方法

和结构体方法类似，使用impl关键字：

impl Message{fn call(&self){}}

这里就不具体实现了，此时枚举的所有变体都可以调用call方法，例如q.call();

2、Option枚举

2.1、引入Option枚举解决控制问题

• Option 是 Rust 标准库中的枚举类，这个类用于填补 Rust 不支持 null 引用的空白。

• 许多语言支持 null 的存在（C/C++、Java），这样很方便，但也制造了极大的问题，null 的发明者也承认这一点，“一个方便的想法造成累计 10 亿美元的损失”。

• null 经常在开发者把一切都当作不是 null 的时候给予程序致命一击：毕竟只要出现一个这样的错误，程序的运行就要彻底终止。

• 为了解决这个问题，很多语言默认不允许 null，但在语言层面支持 null 的出现（常在类型前面用 ? 符号修饰）。

• Java 默认支持 null，但可以通过 @NotNull 注解限制出现 null，这是一种应付的办法。

Rust 在语言层面彻底不允许空值 null 的存在，但无奈null 可以高效地解决少量的问题，所以 Rust 引入了 Option 枚举类：

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

2.2、枚举类的具体使用

枚举类包含在预导入模块中（Prelude），可直接使用：

let some_number=Some(5);let some_string=Some("a string")let absent:Option<&str>=None;

注意：

• 编译器无法推断None是什么类型，所以一定要显示声明
• 由于absent属于None的变体，因此是无效数据，也就是null

3、match控制流运算符

• 枚举的目的是对某一类事物的分类，分类的目的是为了对不同的情况进行描述。
• 基于这个原理，往往枚举类最终都会被分支结构处理（许多语言中的 switch ）。
• switch 语法很经典，但在 Rust 中并不支持，很多语言摒弃 switch 的原因都是因为 switch 容易存在因忘记添加 break 而产生的串接运行问题，Java 和 C# 这类语言通过安全检查杜绝这种情况出现。

Rust 通过 match 语句来实现分支结构。先认识一下如何用 match 处理枚举类：

fn main() {    enum Book { Papery {index: u32}, Electronic {url: String},    }let book = Book::Papery{index: 1001};    let ebook = Book::Electronic{url: String::from("url...")};match book { Book::Papery { index } => {     println!("Papery book {}", index); }, Book::Electronic { url } => {     println!("E-book {}", url); }    }}//运行结果：Papery book 1001

• 这是由于book属于Papery的变体，因此会执行第一个打印语句

match 块也可以当作函数表达式来对待，它也是可以有返回值的：

match 枚举类实例 {    分类1 => 返回值表达式,    分类2 => 返回值表达式,    ...}

• 但是要谨记：所有返回值表达式的类型必须一样！

如果把枚举类附加属性定义成元组，在 match 块中需要临时指定一个名字：

enum Book {    Papery(u32),    Electronic {url: String},}let book = Book::Papery(1001);match book {    Book::Papery(i) => { println!("{}", i);    },    Book::Electronic { url } => { println!("{}", url);    }}

• 变体Papery指定了i变量，Electronic指定了url

match 除了能够对枚举类进行分支选择以外，还可以对整数、浮点数、字符和字符串切片引用（&str）类型的数据进行分支选择。其中，浮点数类型被分支选择虽然合法，但不推荐这样使用，因为精度问题可能会导致分支错误。

对非枚举类进行分支选择时必须注意处理例外情况，即使在例外情况下没有任何要做的事。例外情况用下划线 _ 表示：

fn main() {    let t = "abc";    match t { "abc" => println!("Yes"), _ => {},    }}

4、if let 语法

通过一个简单的流程控制代码理解此部分知识：

let i = 0;match i {    0 => println!("zero"),    _ => {},}//主函数中运行结果：zero

• 这段程序的目的是判断 i 是否是数字 0，如果是就打印 zero。

那么现在用 if let 语法缩短这段代码：

let i = 0;if let 0 = i {    println!("zero");}

if let 语法格式如下：

if let 匹配值 = 源变量 {    语句块}

• 可以在之后添加一个 else 块来处理例外情况。

if let 语法可以认为是只区分两种情况的 match 语句的"语法糖"

在枚举类中的使用：

fn main() {    enum Book { Papery(u32), Electronic(String)    }    let book = Book::Electronic(String::from("url"));    if let Book::Papery(index) = book { println!("Papery {}", index);    } else { println!("Not papery book");    }}//运行结果：Not papery book

Rust 枚举类和模式匹配的知识就分享到这里了，期待你的鼓励，这将是我创作的不竭动力！