# 模式
> [patterns.md](https://github.com/rust-lang/rust/blob/master/src/doc/book/patterns.md)
commit 6ba952020fbc91bad64be1ea0650bfba52e6aab4
模式在Rust中十分常见。我们在[变量绑定](#)，[匹配语句](#)和其它一些地方使用它们。让我们开始一个快速的关于模式可以干什么的教程！
快速回顾：你可以直接匹配常量，并且`_`作为“任何”类型：
~~~
let x = 1;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("anything"),
}
~~~
这会打印出`one`。
有一个模式的陷阱：就像任何引入一个新绑定的语句，他们会引入隐藏。例如：
~~~
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 origin = Point { x: 0, y: 0 };
match origin {
Point { 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, .. } => println!("y is {}", y),
}
~~~
这会输出`y is 0`。
这种“解构”行为可以用在任何复合数据类型上，例如[元组](#)和[枚举](#)
### 忽略绑定（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`，不过省略了中间的元素。
相似的，你可以在模式中用`..`来忽略多个值。
~~~
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 mut 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 } => ...
}
~~~
模式十分强大。好好使用它们。
- 前言
- 贡献者
- 1.介绍
- 2.准备
- 3.学习 Rust
- 3.1.猜猜看
- 3.2.哲学家就餐问题
- 3.3.其它语言中的 Rust
- 4.语法和语义
- 4.1.变量绑定
- 4.2.函数
- 4.3.原生类型
- 4.4.注释
- 4.5.If语句
- 4.6.循环
- 4.7.所有权
- 4.8.引用和借用
- 4.9.生命周期
- 4.10.可变性
- 4.11.结构体
- 4.12.枚举
- 4.13.匹配
- 4.14.模式
- 4.15.方法语法
- 4.16.Vectors
- 4.17.字符串
- 4.18.泛型
- 4.19.Traits
- 4.20.Drop
- 4.21.if let
- 4.22.trait 对象
- 4.23.闭包
- 4.24.通用函数调用语法
- 4.25.crate 和模块
- 4.26.const和static
- 4.27.属性
- 4.28.type别名
- 4.29.类型转换
- 4.30.关联类型
- 4.31.不定长类型
- 4.32.运算符和重载
- 4.33.Deref强制多态
- 4.34.宏
- 4.35.裸指针
- 4.36.不安全代码
- 5.高效 Rust
- 5.1.栈和堆
- 5.2.测试
- 5.3.条件编译
- 5.4.文档
- 5.5.迭代器
- 5.6.并发
- 5.7.错误处理
- 5.8.选择你的保证
- 5.9.外部函数接口
- 5.10.Borrow 和 AsRef
- 5.11.发布途径
- 5.12.不使用标准库
- 6.Rust 开发版
- 6.1.编译器插件
- 6.2.内联汇编
- 6.4.固有功能
- 6.5.语言项
- 6.6.链接进阶
- 6.7.基准测试
- 6.8.装箱语法和模式
- 6.9.切片模式
- 6.10.关联常量
- 6.11.自定义内存分配器
- 7.词汇表
- 8.语法索引
- 9.参考文献
- 附录：名词中英文对照