Rust中的枚举和模式匹配

专栏简介：本专栏作为Rust语言的入门级的文章，目的是为了分享关于Rust语言的编程技巧和知识。对于Rust语言，虽然历史没有C++、和python历史悠远，但是它的优点可以说是非常的多，既继承了C++运行速度，还拥有了Java的内存管理，就我个人来说，还有一个优点就是集成化的编译工具cargo，语句风格和C++极其相似，所以说我本人还是比较喜欢这个语言，特此建立这个专栏，作为学习的记录分享。

日常分享：每天努力一点，不为别的，只是为了日后，能够多一些选择，选择舒心的日子，选择自己喜欢的人！

前面我们提到过，Rust中没有了switch case这种模式控制语句，但是喃，除此之外，却又多了另一种匹配规则，那就是模式匹配。所以这节我们就来聊聊模式匹配这种匹配机制。

1、枚举

枚举其实在c++中就有过定义，二者相差不大，关键字是enum，枚举和结构体一样，也是用来自定义的数据类型。

说到枚举，可能有些同学还不是特别清楚，枚举的意义在那里，其实枚举他只是一个存放字段的一种容器吧，在后面的代码中，如果你需要多种字段，但是你又不是特别明确具体需要哪些，就把所有可能的字段放在其中，需要什么就使用什么。

enum Error{typeError,lengthError,
}

例如上面的代码，定义了一个Error的枚举类型，这个时候，Error就是一个数据类型。

1.1、枚举值

let oneError = Error::typeError;let twoEroor = Error::lengthError;

就如上面的代码，我们定义了两个实例对象，而他们的数值则是Error中的两个字段。

这里注意的是，枚举的成员位于其标识符的命名空间中，并使用两个冒号分开。

但是有人看到这里就会有疑惑，这里的枚举类型中的字段都是没有具体值的，那么我们如何将值与枚举成员关联？

上一节讲解了结构体的概念，这里我们就可以使用结构体来进行绑定：


enum Error{typeError,lengthError,
}struct getError{oneError: Error,twoEroorderError: Error,address:String,
}
let amples = getError{oneError: Error::typeError,twoEroorderError: Error::lengthError,address:String::from("Hello world"),
};

上面所时代码就是将枚举作为结构体的一部分，除了上面的方法，我们似乎还可以使用其他方法,例如将数据放进每一个枚举成员。

enum Error{typeError(String),lengthError(String),
}
let oneError = Error::typeError(String::from("one error"));
let twoEroor = Error::lengthError(String::from("two Eroor error"));

1.2、Option枚举

前面写的代码中，对于枚举数据类型，虽然将值通过结构体进行了绑定，但是却没有具体的值，只有通过将值放进枚举成员，才能获得值。那么没有的值又是什么？或者说又有什么作用？

Rust语言和其他语言的一点不同就在于它没有空值，也就是说不能赋予空值，必须去实现。Rust 并没有空值，不过它确实拥有一个可以编码存在或不存在概念的枚举。

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

Option<T> 枚举是如此有用以至于它甚至被包含在了 prelude 之中，你不需要将其显式引入作用域。另外，它的成员也是如此，可以不需要 Option:: 前缀来直接使用 Some 和 None。这里要注意，Option枚举是含在标准库的，不需要我们定义，直接使用，上面知识给出参考。

<T> 语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数,后面遇到了我们再详细介绍。

  let some_number = Some(5);let some_char = Some('e');let number:Option<i32>=None;

上面的三条语句，变量some_number的类型是i32，some_char的类型是char，而number的类型是i32，只是是一个空值。对于Option<T>，这里的T可以是任何数据类型，除了赋空值外，一般来说不需要注明变量的数据类型，除非是特殊需要，Rust可以推断其变量的数据类型。如果是赋空值，就必须注明变量的数据类型，否则会报错。

不过这里需要注意的是，Option<T>标注的数据类型与相同的数据类型变量不能进行运算.

  let one_num:Option<i32>=some(20);let s:i32=30;println!("{}",one_num+s);

error[E0425]: cannot find function `some` in this scope
--> src/main.rs:45:27
   |
45 |   let one_num:Option<i32>=some(20);
   |                           ^^^^ help: a tuple variant with a similar name exists (notice the capitalization): `Some`

error[E0369]: cannot add `i32` to `Option<i32>`
--> src/main.rs:47:24
   |
47 |   println!("{}",one_num+s);
   |                 -------^- i32
   |                 |
   |                 Option<i32>

Some errors have detailed explanations: E0369, E0425.
For more information about an error, try `rustc --explain E0369`.
error: could not compile `number` due to 2 previous errors

当运行上述代码的时候就会出现这种报错,这是为什么喃?这是由于当我们使用Option<T> 数据类型的时候就表明该数据可能为空,而我们使用i32(或其他数据类型)的时候,就已经表明改变两不可能为空值,所以才会出现报错,根本原因还是在与其数据类型被系统判定为两种数据类型.

换句话说，在对 Option<T> 进行运算之前必须将其转换为 T。通常这能帮助我们捕获到空值最常见的问题之一：假设某值不为空但实际上为空的情况。

消除了错误地假设一个非空值的风险，会让你对代码更加有信心。为了拥有一个可能为空的值，你必须要显式的将其放入对应类型的 Option<T> 中。接着，当使用这个值时，必须明确的处理值为空的情况。只要一个值不是 Option<T> 类型，你就可以安全的认定它的值不为空。这是 Rust 的一个经过深思熟虑的设计决策，来限制空值的泛滥以增加 Rust 代码的安全性。

那么当有一个 Option<T> 的值时，如何从 Some 成员中取出 T 的值来使用它呢？Option<T> 枚举拥有大量用于各种情况的方法：你可以查看它的文档。熟悉 Option<T> 的方法将对你的 Rust 之旅非常有用。

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

2、match控制流结构

我们前面说了在Rust语言中没有switch这种控制流语句，但是它却推出了match这种强大的控制流运算符。在python语言中，match是正则表达式中的匹配函数，所以这里也可以理解为匹配函数。

先来看个例子：

enum error_message{E0425,E0369,E2345,
}
fn get_error_message(message:error_message)->u32{match message{error_message::E0425 =>{println!("cannot find function `some` in this scope");return 0;}error_message::E0369=>{println!("cannot add `i32` to `Option<i32>");return 1;}error_message::E2345=>{println!("could not compile `number` due to 2 previous errors");return 2;}}
}
fn main(){let mut error=get_error_message(error_message::E2345);println!("{}",error);get_error_message(error_message::E0425);
}

就如上面的代码，先是定义了一个枚举数据类型，然后定义了一个函数，在函数中使用了match控制流。根据不同的参数值，返回不同的值，并打印出结果。

1.1、绑定值模式

匹配分支的另一个有用的功能是可以绑定匹配的模式的部分值。这也就是如何从枚举成员中提取值的。

/*
enum error_message{E0425,E0369,E2345,
}
fn get_error_message(message:error_message)->u32{match message{error_message::E0425 =>{println!("cannot find function `some` in this scope");return 0;}error_message::E0369=>{println!("cannot add `i32` to `Option<i32>");return 1;}error_message::E2345=>{println!("could not compile `number` due to 2 previous errors");return 2;}}
}
fn main(){let mut error=get_error_message(error_message::E2345);println!("{}",error);get_error_message(error_message::E0425);
}
*/
#[derive(Debug)]
enum UsState{Alabama,Alaska,
}
enum Coin{Penny,Nickel,Dime,Quarter(UsState),
}
fn value_cents(coin:Coin) -> usize {match coin{Coin::Penny =>{return 1;}Coin::Nickel =>{return 5;}Coin::Dime =>{return 10;}Coin::Quarter(state)=>{println!("State quarter from {:#?}",state);return 25;}}
}
fn main()
{let b=UsState::Alaska;let c=Coin::Quarter(b);value_cents(c);}

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

1.2、匹配Option<T>

我们在之前的部分中使用 Option<T> 时，是为了从 Some 中取出其内部的 T 值；我们还可以像处理 Coin 枚举那样使用 match 处理 Option<T>！只不过这回比较的不再是硬币，而是 Option<T> 的成员，但 match 表达式的工作方式保持不变。

例如：

fn plus_amount(amount:Option<i32>)->Option<i32> 
{match amount {None=>{println!("该值为空值");return None;}Some(i)=>{println!("该值不是空值，值为{}",i);return Some(i);}}
}
fn main(){let five=Some(5);let num1=plus_amount(five);plus_amount(None);
}

1.3、通配模式和_占位符

其实除了枚举，match控制流也可以用于其他形式，比如：

let num=30;match num{10=>{println!("10");}11 => println!("11"),other => println!("other"),}

上面的代码中，我们在最后使用了other这个变量，这个变量覆盖了所有其他的可能值，除了我们列出来的可能性，other会包含所有的其他可能性，所以other一定要放在最后，否无法达到目的。

不过在这里因该有人发现了，other会绑定match匹配的值，这个我们将上面的程序更改一下，就能的出这个结论：

fn main(){let five=Some(5);let num1=plus_amount(five);plus_amount(None);let num=30;match num{10=>{println!("10");}11 => println!("11"),other => println!("other的值为:{}",other),}
}

other的值为:30

上面就是输出结果，这说明other绑定到了match匹配的值上，这样做的好处就是可以获得匹配值，将其进行使用，但是如果我们不需要使用那个值，这样做就有点浪费，所以Rust也推出了_占位符，占位符只是表示可以匹配任意值而不能绑定到该值。

fn main(){let five=Some(5);let num1=plus_amount(five);plus_amount(None);let num=30;match num{10=>{println!("10");}11 => println!("11"),_ => println!("other"),}
}

3、if let间接控制流

Rust中的if let控制流说的简单点，就相当于c++中的if else语句，对于一些简单的判别，使用if let控制流语句将会简单很多。例如：

fn main() 
{let config=Some(3u8);match config{Some(max)=>println!("{}",max),_=>(),}
}

上面面代码的意思是，匹配config的值，如果值是Some，就将值绑定到max变量上，然后输出，否则就忽略。

除了上面这样的方式，我们还可以使用其他的方式：

fn main() 
{let config=Some(3u8);if let Some(max)=config{println!("{}",max);}
}

这样看来是不是就简单的多了，所以说从某种角度来看，if let语句确实简单了很多。

#[derive(Debug)]
enum UsState{Alabama,Alaska,
}
enum Coin{Penny,Nickel,Dime,Quarter(UsState),
}
fn main() 
{let mut count=0;let b=UsState::Alaska;let coin=Coin::Quarter(b);//以下两种方式都可以/*match coin{Coin::Quarter(state)=>{println!("State quarter from {:#?}",state);}_=>count+=1,}*/if let Coin::Quarter(state) = coin{println!("State quarter from {:#?}",state);}else{count+=1;}
}