Protected-Site-00 Never Ever 2024-02-28T08:34:39.155Z http://blog.drscorpio.site/ Dr_Scorpio Hexo Rust-枚举和Match匹配 http://blog.drscorpio.site/2024/02/28/rust-match/ 2024-02-28T02:56:49.000Z 2024-02-28T08:34:39.155Z

系列文章

  1. Rust-引用与借用
  2. Rust-枚举和Match匹配

在上一篇文章里，我们探讨了Rust中的一个重要概念——引用和借用。在这篇文章中，我们将继续探讨本人在通过Rustling学习Rust中遇到的第二个问题——枚举(Enum)和模式匹配(Match)

枚举（Enum）

枚举通过关键字enum来声明，通过enum关键字我们可以声明一个指定的枚举类型。
比如在Rust圣经中的一个例子: 

1
2
3
4
5
6
enum PokerSuit{
    Clubs,
    Spades,
    Diamonds,
    Hearts,
}

这里我们声明了一个枚举类型PockerSuit,其中包含了4种枚举值:Clubs,Spades,Diamonds,Hearts。之后，我们便可以使用它们了，比如我们可以创建两个PockerSuit类型的成员实例： 

1
2
3
4
5
6
7
8
9
10
11
12
    let heart = PokerSuit::Heart;
    let clubs = PokerSuit::Clubs;
```  

与其他语言不同,Rust可以将不同的数据类型直接关联到枚举成员上，例如我们给上文的扑克花色关联上具体的点数大小:    
```rust
enum PokerSuit{
    Clubs(u8),
    Spades(u8),
    Diamonds(u8),
    Hearts(u8),
}

之后我们便可以给枚举类型的成员实例附上值了，这可比golang好用多了： 

1
2
let d12 = PockerSuit::Diamonds(12);
let s13 = PockerSuit::Spades(13)

当然，我们可不满足于此，对于同一枚举类型的不同的枚举成员，我们还可以给他关联上不同的数据类型：

1
2
3
4
5
6
enum Message{
    Str(String),
    Num(i32),
    Ok(bool),
    Tuple(i32,String,bool)//这里关联了个元组
}

我们甚至可以关联结构体或其他枚举类型： 

1
2
3
4
5
6
7
8
9
10
11
12
//enum
enum PokerSuit{
    Clubs(u8),
    Spades(u8),
    Diamonds(u8),
    Hearts(u8),
}

enum Poker{
    Suit(PokerSuit),
    Flip(bool),
}
1
2
3
4
5
6
7
8
9
10
11
12
//struct
struct ArmedHelicopter{
    Missile:String,
    Type:String,
    Pilot:String,
}

enum Gender{
    Male(String),
    FeMale(String),
    Other(ArmedHelicopter),
}

真是强而有力，强而有力啊

Match——匹配

当我们成功声明了一个枚举类型之后可能会遇到一个问题：如何处理同一枚举类型下的不同枚举值？它们可能对应的是不同的数据类型。
幸运的是，Rust给我们提供了模式匹配来方便我们对不同的枚举值进行处理，本文我们先探讨第一种模式匹配方法——match

如何使用

我们首先来看看match的通用形式

1
2
3
4
5
6
7
8
9
match target {
    模式1 => 表达式1,
    模式2 => {
        语句1;
        语句2;
        表达式2
    },
    _ => 表达式3
}

要注意：

  • match的每一个分支都必须是一个表达式，且所有分支的表达式最终返回值的类型必须相同。
  • match的匹配必须要穷举出所有可能，这里使用_来匹配除了模式1和模式2以外的其他所有情况
  • 匹配的模式可以使用|来表示逻辑运算中的或，从而匹配多种模式，例如模式3 | 模式4 => 表达式foo，

注意！这里只能使用|，不能使用||、&&、!等逻辑运算符，match的模式匹配中每个匹配臂（arm）的模式必须是独立的，如果想要更复杂的匹配方式，需要添加匹配守卫(Pattern guard)，来进一步改进匹配标准,关于匹配守卫，我们应该会在后面的文章中进一步探讨。

这里展示一个简单的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
enum PokerSuit{
    Clubs,
    Spades,
    Diamonds,
    Hearts,
}

fn show_poker_suit(suit:PokerSuit) -> char{
    match suit {
        PokerSuit::Clubs => '♣',
        PokerSuit::Heart =>{
            println!("♥!");
            '♥';
        },
        PokerSuit::Spades =>'♠',
        PokerSuit::Diamonds =>'♦',
    }
}

使用match表达式赋值

match 本身也是一个表达式，因此可以用它来赋值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//偷了一个Rust圣经的例子
enum IpAddr {
   Ipv4,
   Ipv6
}

fn main() {
    let ip1 = IpAddr::Ipv6;
    let ip_str = match ip1 {
        IpAddr::Ipv4 => "127.0.0.1",
        _ => "::1",
    };

    println!("{}", ip_str);
}

因为这里匹配到_分支，所以将"::1" 赋值给了ip_str。

模式绑定

终于来到了重头戏（这篇文章就是为了这个而生的），match的一个重要功能就是从模式中取出绑定的值，例如我们在枚举中举的一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#[derive(Debug)]
enum Message{
    Str(String),
    Num(i32),
    Ok(bool),
    Tuple(i32,String,bool)
}

fn show_message(msg Message) -> String{
    match msg {
        Message::Str(strmsg) => strmsg,//这里将Str存储的字符串类型的值绑定在了变量strmsg上
        Message::Num(nummsg) => nummsg.to_string(),
        Message::Ok(okmsg) => format!("{}",okmsg),
        Message::Tuple(x,y,z) => format!("({}, {}, {})",x,y,z)
    }
}

穷尽匹配

简单来说，如果你在match中没有列出所有可能的匹配情况，cargo会报错 Cargo：写的什么垃圾代码，你给我去屎吧

_通配符

当我们不想在匹配时列出所有值的时候，可以使用 Rust 提供的一个特殊模式_通配符，比如我们的函数只关心PokerSuit中的红牌：

1
2
3
4
5
6
7
fn show_me_red(suit:PokerSuit) -> String{
    match suit {
        PokerSuit::Hearts => "I got ♥ !".to_string(),
        PokerSuit::Diamonds => "I got ♦!".to_string(),
        _ => "I got smoke :( ".to_string()//吸烟有害健康
    }
}

当然，除了_，我们也可以用其他变量来承载其他情况：

1
2
3
4
5
6
7
fn show_me_red(suit:PokerSuit) -> String{
    match suit {
        PokerSuit::Hearts => "I got ♥ !".to_string(),
        PokerSuit::Diamonds => "I got ♦!".to_string(),
        other => format!("I got {:#?}",other),
    }
}

总结

Rust提供了强大的枚举和match匹配来使得我们的代码更加简洁美观，让我们可以摆脱丑陋的if else，在后面的文章里（如果有的话），我们会进一步探讨其他的模式匹配方法，以及之前提到的匹配守卫(Pattern guard)。

部分内容引用自Rust语言圣经(Rust Course)

]]> <blockquote> <p><strong>系列文章</strong> </p> <ol><li><a href="/2024/02/27/Rust-Borrowing/" title="Rust-引用与借用">Rust-引用与借用</a></li><li><a href= Rust-引用与借用 http://blog.drscorpio.site/2024/02/27/Rust-Borrowing/ 2024-02-27T02:43:20.000Z 2024-02-28T08:34:40.679Z

系列文章

  1. Rust-引用与借用
  2. Rust-枚举和Match匹配

在上一篇文章中，我们开始使用Rustling来学习Rust语言，本文我们将探讨在学习过程中遇到的第一个难点 引用与借用

导言

在Rustling的move_semantics6练习中我们将接触到Rust语言与其他编程语言最大的差异，引用和借用
让我们首先来看看题目：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fn main() {
    let data = "Rust is great!".to_string();

    get_char(data);

    string_uppercase(&data);
}
// Should not take ownership
fn get_char(data: String) -> char {
    data.chars().last().unwrap()
}
// Should take ownership
fn string_uppercase(mut data: &String) {
    data = &data.to_uppercase();

    println!("{}", data);
}

ps:题目中删除了一些不必要的注释，因为他们不重要

在声明的两个函数中，我们需要对参数字符串进行不同的操作，其中:

  • get_char()，要求我们返回字符串的最后一个字符
  • string_uppercase()要求我们将字符串转换为全大写字符
    从函数效果来看，不难发现，get_char()函数不需要我们对传入的参数进行修改，而string_uppercase()需要我们对传入的参数进行修改。

在main()函数中，我们声明了一个变量data，并将字符串"Rust is Great!"雀食赋给了它，随后我们使用声明的两个函数get_char()，和string_uppercase()对这个变量进行操作。

问题

当我们运行这段代码的时候，出现了一点小小的问题，cargo告诉我们：

1
2
3
4
5
6
7
8
9
error[E0382]: borrow of moved value: `data`
  --> exercises/move_semantics/move_semantics6.rs:15:22
13 |     get_char(data);
   |              ---- value moved here
14 |
15 |     string_uppercase(&data);
   |                      ^^^^^ value borrowed here after move
error[E0716]: temporary value dropped while borrowed
error: aborting due to 2 previous errors

这里省略了一些输出，因为虽然他们很有用，但是放在文章阅读就不太友好了

原因与解决方案

上文两个error其实都是一个原因导致的：

  1. 我们先将data的所有权交给了get_char()函数
  2. 然后又将data借用给了string_uppercase()

在get_char函数运行时，data的所有权已经转移给了它，待函数结束之后，data已经移出了作用域，所以后续的string_uppercase()就无法在借用data的值了

当然，我们的解决方法也很简单，根据注释来修改这两个函数的传入参数就可以了。
因为在get_char()中，我们不需要修改参数的值，所以这里应该传入的是一个借用。

1
2
3
fn get_char(data: &String/*这里修改为借用*/) -> char {
    data.chars().last().unwrap()
}

而在string_uppercase()中，我们需要修改参数的值，所以这里应该获得参数的所有权

1
2
3
4
fn string_uppercase(mut data: String/*这里删除&*/) {
    data = data.to_uppercase();
    println!("{}", data);
}

最后再修改一下main就大功告成了
完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
fn main() {
    let data = "Rust is great!".to_string();

    get_char(&data);

    string_uppercase(data);
}

// Should not take ownership
fn get_char(data: &String) -> char {
    data.chars().last().unwrap()
}

// Should take ownership
fn string_uppercase(mut data: String) {
    data = data.to_uppercase();

    println!("{}", data);
}
]]> <blockquote> <p><strong>系列文章</strong></p> <ol><li><a href="/2024/02/27/Rust-Borrowing/" title="Rust-引用与借用">Rust-引用与借用</a></li><li><a href="/ 初试Rustlings-Rustlings安装部署和尝试 http://blog.drscorpio.site/2024/02/22/using-rustling/ 2024-02-22T06:29:03.000Z 2024-02-28T02:56:59.715Z 今天在互联网闲逛的时候无意中发现了Rustlings这个项目，刚好最近有在打算学习Rust，于是抱着试试的心态尝试了一下

安装

推荐使用官网的手动安装方法

  1. Clone官方的仓库
    1
    2
    3
    # find out the latest version at https://github.com/rust-lang/rustlings/releases/latest (on edit 5.6.1)
    git clone -b 5.6.1 --depth 1 https://github.com/rust-lang/rustlings
    cd rustings
  2. 用cargo安装
    1
    cargo install --force --path .
  3. 最后运行rustup 建议挂梯子，否则可能非常漫长
    1
    rustup update

使用

官方文档给出了具体的命令，详情查阅官网下的Doing exercises部分

  1. 在安装目录下打开终端，输入rustlings watch启动Rustlings,本人这里使用了VScode内置的终端来方便使用
  2. 根据命令行提示完成对应练习，练习用的rs文件在目录下的/exercises/文件夹内，rustlings在检测到文件变动后会自动编译检查。
  3. 完成练习后删除注释中的I AM NOT DONE来进行下一个练习

总结

目前本人只是简单完成了2、3个练习内容，后续的进度也会在博客中及时更新 大概

]]> <p><strong>今天在互联网闲逛的时候无意中发现了Rustlings这个项目，刚好最近有在打算学习Rust，于是抱着试试的心态尝试了一下</strong></p> <h1 id="安装"><a href="#安装" class="headerlink" title="安装" 复活！ http://blog.drscorpio.site/2024/02/21/NewStart/ 2024-02-21T04:24:22.000Z 2024-02-28T04:06:55.556Z 原身，启动！

努力重建博客中…

]]> <p>原身，启动！</p> <p>努力重建博客中…</p>