模式
- 多重模式（Multiple patterns）
- 解构（Destructuring）
- 忽略绑定（Ignoring bindings）
- ref和ref mut
- 范围（Ranges）
- 绑定
- 守卫（Guards）
- 混合与匹配（Mix and Match）

模式

patterns.md

commit ccb1d87d6faa9ff528d22b96595a0e2cbb16c0f2

模式在Rust中十分常见。我们在变量绑定，匹配表达式和其它一些地方使用它们。让我们开始一个快速的关于模式可以干什么的教程！

快速回顾：你可以直接匹配常量，并且_作为“任何”类型：

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

这会打印出one。

可以在任何分支创建值的绑定：

let x = 1;
match x {
    y => println!("x: {} y: {}", x, y),
}

这会打印出：

x: 1 y: 1

注意在同一匹配块中同时拥有捕获全部的_和捕获全部的绑定会产生错误：

let x = 1;
match x {
    y => println!("x: {} y: {}", x, y),
    _ => println!("anything"), // this causes an error as it is unreachable
}

这里有一个模式的陷阱：就像任何引入一个新绑定的语句，他们会引入隐藏。例如：

let x = 1;
let c = 'c';
match c {
    x => println!("x: {} c: {}", x, c),
}
println!("x: {}", x)

这会打印：

x: c c: c
x: 1

换句话说，x =>匹配到了模式并引入了一个叫做x的新绑定。这个新绑定的作用域是匹配分支并拥有c的值。注意匹配作用域外的x的值对内部的x的值并无影响。因为我们已经有了一个x，新的x隐藏了它。

多重模式（Multiple patterns）

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

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

这会输出one or two。

解构（Destructuring）

如果你有一个复合数据类型，例如一个结构体，你可以在模式中解构它：

struct Point {
    x: i32,
    y: i32,
}
let origin = Point { x: 0, y: 0 };
match origin {
    Point { x, y } => println!("({},{})", x, y),
}

我们可以用:来给出一个不同的名字：

struct Point {
    x: i32,
    y: i32,
}
let origin = Point { x: 0, y: 0 };
match origin {
    Point { x: x1, y: y1 } => println!("({},{})", x1, y1),
}

如果你只关心部分值，我们不需要给它们都命名：

struct Point {
    x: i32,
    y: i32,
}
let point = Point { x: 2, y: 3 };
match point {
    Point { x, .. } => println!("x is {}", x),
}

这会输出x is 2。

你可以对任何成员进行这样的匹配，不仅仅是第一个：

struct Point {
    x: i32,
    y: i32,
}
let point = Point { x: 2, y: 3 };
match point {
    Point { y, .. } => println!("y is {}", y),
}

这会输出y is 3。

这种“解构”行为可以用在任何复合数据类型上，例如元组和枚举

忽略绑定（Ignoring bindings）

你可以在模式中使用_来忽视它的类型和值。例如，这是一个Result<T, E>的match：

# let some_value: Result<i32, &'static str> = Err("There was an error");
match some_value {
    Ok(value) => println!("got a value: {}", value),
    Err(_) => println!("an error occurred"),
}

在第一个分支，我们绑定了Ok变量中的值为value，不过在Err分支，我们用_来忽视特定的错误，而只是打印了一个通用的错误信息。

_在任何创建绑定的模式中都有效。这在忽略一个大大结构体的部分字段时很有用：

fn coordinate() -> (i32, i32, i32) {
    // Generate and return some sort of triple tuple.
# (1, 2, 3)
}
let (x, _, z) = coordinate();

这里，我们绑定元组第一个和最后一个元素为x和z，不过省略了中间的元素。

值得注意的是，_ 一开始并不绑定值，这意味着值可能并没有被移动（这里涉及到 Move 和 Copy，应该就是说你不用它的话就不会 Move）：

let tuple: (u32, String) = (5, String::from("five"));
// Here, tuple is moved, because the String moved:
let (x, _s) = tuple;
// The next line would give "error: use of partially moved value: `tuple`".
// println!("Tuple is: {:?}", tuple);
// However,
let tuple = (5, String::from("five"));
// Here, tuple is _not_ moved, as the String was never moved, and u32 is Copy:
let (x, _) = tuple;
// That means this works:
println!("Tuple is: {:?}", tuple);

这也意味着任何临时变量将会在语句结束时立刻被释放掉：

// Here, the String created will be dropped immediately, as it’s not bound:
let _ = String::from("  hello  ").trim();

你也可以在模式中用..来忽略多个值。

enum OptionalTuple {
    Value(i32, i32, i32),
    Missing,
}
let x = OptionalTuple::Value(5, -2, 3);
match x {
    OptionalTuple::Value(..) => println!("Got a tuple!"),
    OptionalTuple::Missing => println!("No such luck."),
}

这会打印Got a tuple!。

`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关键字创建了一个在模式中使用的引用。如果你需要一个可变引用，ref mut同样可以做到：

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

范围（Ranges）

你可以用...匹配一个范围的值：

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

这会输出one through five。

范围经常用在整数和char上。

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 x: Option<Person> = Some(Person { name: Some(name) });
match x {
    Some(Person { name: ref a @ Some(_), .. }) => println!("{:?}", a),
    _ => {}
}

这会输出 Some("Steve")，因为我们把Person里面的name绑定到a。

如果你在使用|的同时也使用了@，你需要确保名字在每个模式的每一部分都绑定名字：

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

守卫（Guards）

你可以用if来引入匹配守卫（match guards）：

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!。

如果你在if中使用多重模式，if条件将适用于所有模式：

let x = 4;
let y = false;
match x {
    4 | 5 if y => println!("yes"),
    _ => println!("no"),
}

这会打印no，因为if适用于整个4 | 5，而不仅仅是5，换句话说，if语句的优先级是这样的：

(4 | 5) if y => ...

而不是这样：

4 | (5 if y) => ...

混合与匹配（Mix and Match）

(口哨)！根据你的需求，你可以对上面的多种匹配方法进行组合：

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

模式十分强大。好好使用它们。

4.15.模式

模式