使用過正則表達式的人應該都知道 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。

Rust 1.7.0 匹配器 match 的簡介和使用