专栏简介：本专栏作为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;
  }
}

4、总结

现在我们涉及到了如何使用枚举来创建有一系列可列举值的自定义类型。我们也展示了标准库的 Option<T> 类型是如何帮助你利用类型系统来避免出错的。当枚举值包含数据时，你可以根据需要处理多少情况来选择使用 match 或 if let 来获取并使用这些值。

你的 Rust 程序现在能够使用结构体和枚举在自己的作用域内表现其内容了。在你的 API 中使用自定义类型保证了类型安全：编译器会确保你的函数只会得到它期望的类型的值。

下一节我们学习模块系统。