模式

模式在 Rust 中頗為常見。我們在變量綁定，match語句和其他地方也使用它們。讓我們繼續(xù)旋風般的學習模式可以做的所有事情!

快速學習：你可以直接匹配文字，同時 _ 充當一個‘任何’的事件：

let x = 1;

match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("anything"),
}

以上代碼將打印 one。

多個模式

你可以使用 | 來匹配多個模式：

let x = 1;

match x {
1 | 2 => println!("one or two"),
3 => println!("three"),
_ => println!("anything"),
}

以上代碼將打印 one or two。

范圍

你可以使用 ... 來匹配值的范圍：

let x = 1;

match x {
1 ... 5 => println!("one through five"),
_ => println!("anything"),
}

以上代碼將打印 one through five。

范圍通常在整數和字符的情況下使用：

let x = '????';

match x {
'a' ... 'j' => println!("early letter"),
'k' ... 'z' => println!("late letter"),
_ => println!("something else"),
}

以上代碼將打印 something else。

綁定

你可以使用 @ 將值綁定到名稱：

let x = 1;

match x {
e @ 1 ... 5 => println!("got a range element {}", e),
_ => println!("anything"),
}

以上代碼將打印 got a range element 1。當你想要操作數據結構中的一部分的一個復雜匹配時，這將非常有用：

#[derive(Debug)]
struct Person {
name: Option<String>,
}

let name = "Steve".to_string();
let mut x: Option<Person> = Some(Person { name: Some(name) });
match x {
Some(Person { name: ref a @ Some(_), .. }) => println!("{:?}", a),
_ => {}
}

以上代碼將打印 Some("Steve")：我們已經把內部名稱綁定到 a。

如果你使用 @ 和 | 時，你需要確保在模式的每個部分都已經綁定好名稱。

let x = 5;

match x {
e @ 1 ... 5 | e @ 8 ... 10 => println!("got a range element {}", e),
_ => println!("anything"),
}

忽略變量

如果你要匹配一個包含變量的枚舉，你可以使用 .. 來忽略變量的值和類型：

enum OptionalInt {
Value(i32),
Missing,
}

let x = OptionalInt::Value(5);

match x {
OptionalInt::Value(..) => println!("Got an int!"),
OptionalInt::Missing => println!("No such luck."),
}

以上代碼將輸出 Got an int！。

守衛(wèi)

你可以通過 if 語句來介紹‘守衛(wèi)匹配’：

enum OptionalInt {
Value(i32),
Missing,
}

let x = OptionalInt::Value(5);

match x {
OptionalInt::Value(i) if i > 5 => println!("Got an int bigger than five!"),
OptionalInt::Value(..) => println!("Got an int!"),
OptionalInt::Missing => println!("No such luck."),
}

以上代碼將輸出 Got an int！。

ref 和 ref mut

如果你想要獲得一個引用，可以使用 ref 關鍵字：

let x = 5;

match x {
ref r => println!("Got a reference to {}", r),
}

以上代碼將打印出 Got a reference to 5。

在這里，在 match 中的 r 的類型為 &i32。換句話說，在模式中，使用 ref 關鍵字創(chuàng)建一個引用以供使用。如果你需要一個可變引用，ref mut 將會以相同的方式工作：

let mut x = 5;

match x {
ref mut mr => println!("Got a mutable reference to {}", mr),
}

重構

如果你有一個復合數據類型，諸如結構體，你可以在一個模式中重構它：

struct Point {
x: i32,
y: i32,
}

let origin = Point { x: 0, y: 0 };

match origin {
Point { x: x, y: y } => println!("({},{})", x, y),
}

如果我們只關心一部分值，我們不需要給出它們所有的名字：

struct Point {
x: i32,
y: i32,
}

let origin = Point { x: 0, y: 0 };

match origin {
Point { x: x, .. } => println!("x is {}", x),
}

以上代碼將打印出 x is 0。

你可以在任何成員中做這種匹配，而不僅僅是第一個成員：

struct Point {
x: i32,
y: i32,
}

let origin = Point { x: 0, y: 0 };

match origin {
Point { y: y, .. } => println!("y is {}", y),
}

以上代碼將打印出 y is 0。

這種‘重構’行為對于任何復合數據類型都有效，比如數組或者枚舉。

混合與匹配

這里有很多種不同的方法來匹配東西，它們又可以被混合和匹配，完全取決于你做什么任務：

match x {
Foo { x: Some(ref name), y: None } => ...
}

模式非常強大。充分利用它。