使用过正則表達式的人应该都知道 matcher ,通过 matcher 匹配器运算正則表達式，完毕一系列的匹配规则。

在Rust 中 没有 switch 语句。matcher 就是 switch 的一个变形，但比其它语言中的 switch 更强大!

一、简单举例说明

简单的 matcher 和 if 语句很相似，假设是简单的条件推断能够用if语句：

let n = 5;

if n < 0 {
    print!("{} is negative", n);
} else if n > 0 {
    print!("{} is positive", n);
} else {
    print!("{} is zero", n);
}

复杂一些的条件推断，使用 if 语句就有些力不从心了。

match 能够这样：

let x = 5;

match x {
    1 => println!("one"),
    2 => println!("two"),
    3 => println!("three"),
    4 => println!("four"),
    5 => println!("five"),
    _ => println!("something else"),
}

假设 x == 1 ,打印 one
假设 x == 2, 打印 two
假设 x == 3, 打印 three
假设 x == 4, 打印 four
假设 x == 5, 打印 five
假设没有与 x 匹配的值。
则运行 _ 相应的语句，打印 something else。

解释一下上面的代码的match语句，

match 是关键字。
x 是表达式。（非结构化的文本表达式）
match语句内容包括在 ｛｝大括号里；
括号里的每一个 => 叫做 match-arm。
大括号里能够包括随意多个 match-arm。
当 x 存在可能不匹配的情况时，大括号里必须包括 _ => 来覆盖不论什么不匹配的情况下运行的语句，就像 switch 中的 default 一样。

match语句中 x 表达式的值。要与｛｝大括号里的每一个match-arm分支进行匹配。

假设匹配，则运行匹配 match-arm 中 =>后面的语句。

match本身也是个表达式，Rust就是基于表达式的语言。

表达式是能够作为右值使用的。

所谓右值，就是看一个表达式是否能放到等号的＝等号右边。
比方x = 1+2，1＋2能够发到＝的右边。所以 1＋2能够是个右值；
可是 1＋2 ＝ x，这个语句中1+2不能放到＝等号的左边，所以 1＋2不可能是左值。

let x = 5;

let number = match x {
    1 => "one",
    2 => "two",
    3 => "three",
    4 => "four",
    5 => "five",
    _ => "something else",
};

这个 match 语句完毕了 数字 变 字符 的转换，number中的值是 five 。

二、另外几个样例

单值、多值和范围匹配

let number = 13;   
println!("Tell me about {}", number);
match number {
    1 => println!("One!"),
    2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
    13...19 => println!("A teen"),
    _ => println!("Ain't special"),
}

布尔值的样例

  let boolean = true;
  let binary = match boolean {
   false => 0,
    true => 1,
  };  
  println!("{} -> {}", boolean, binary);

这里不存在 _ =>这个 match-arm。是由于 true 和 false这两个值已经全然覆盖boolean的全部值域。

枚举的样例

enum Message {
    Quit,
    ChangeColor(i32, i32, i32),
    Move { x: i32, y: i32 },
    Write(String),
}

fn quit() { /* ... */ }
fn change_color(r: i32, g: i32, b: i32) { /* ... */ }
fn move_cursor(x: i32, y: i32) { /* ... */ }

fn process_message(msg: Message) {
    match msg {
        Message::Quit => quit(),
        Message::ChangeColor(r, g, b) => change_color(r, g, b),
        Message::Move { x: x, y: y } => move_cursor(x, y),
        Message::Write(s) => println!("{}", s),
    };

这里的 match msg 也没有实现 _ => 这个match-arm，是由于match msg 里面的值全然覆盖了枚举 Message 中的值，假设把match msg 中的随意一个 match-arm 去掉，就必须实现 _ => 语句了。

match msg {
        Message::ChangeColor(r, g, b) => change_color(r, g, b),
        Message::Move { x: x, y: y } => move_cursor(x, y),
        Message::Write(s) => println!("{}", s),
        _=> quit(),
    };

条件选择

let n  = 3;
match n  {
  n if n > 2 => println!("> 2"),
  n if n < 3 => println!("< 3"),
  _ => println!("some else"),
};

在 match-arm的 => 前面能够有一个if 条件。即使 match 匹配。还能够通过 if 进行过滤。

假设这样，又怎样呢？

let n  = 4;
match n  {
  n if n > 2 => println!("> 2"),
  n if n > 3 => println!("> 3"),
  _ => println!("some else"),
};

match 遇到第一个匹配的结果，就不再往下继续匹配了，仅仅运行第一个满足条件的语句。

上面的代码变体：

let n  = 4;
match n  {
  x => println!(" x = {}",x),
};

x 被赋值 n ，即：let x = n。