match 模式匹配
什么是 match
match 是 Rust 中最强大的控制流结构,它把一个值和一系列模式逐个对比,执行第一个匹配的分支。match 要求穷尽所有可能——每个可能的值都必须被某个分支覆盖到,否则编译不通过。
rust
fn main() {
let number = 3;
match number {
1 => println!("一"),
2 => println!("二"),
3 => println!("三"), // 匹配这个
4 => println!("四"),
_ => println!("其他"), // _ 匹配所有剩余情况
}
}基本语法
rust
fn main() {
let x = 42;
// match 也是表达式,可以返回值
let description = match x {
0 => "零",
1..=9 => "个位数",
10..=99 => "两位数",
100..=999 => "三位数",
_ => "更大的数",
};
println!("{} 是{}", x, description);
// 每个分支可以是代码块
let result = match x {
0 => {
println!("是零");
0
}
n if n > 0 => {
println!("{} 是正数", n);
n * 2
}
_ => {
println!("是负数");
-1
}
};
println!("结果:{}", result);
}匹配枚举
match 最经典的用法就是匹配枚举的各个变体。
rust
enum Direction {
Up,
Down,
Left,
Right,
}
enum Message {
Quit,
Echo(String),
Move { x: i32, y: i32 },
Color(u8, u8, u8),
}
fn handle_direction(dir: Direction) {
match dir {
Direction::Up => println!("向上移动"),
Direction::Down => println!("向下移动"),
Direction::Left => println!("向左移动"),
Direction::Right => println!("向右移动"),
}
}
fn handle_message(msg: Message) {
match msg {
// 匹配无数据的变体
Message::Quit => println!("退出"),
// 匹配带数据的变体,绑定内部值
Message::Echo(text) => println!("回显:{}", text),
// 匹配带命名字段的变体
Message::Move { x, y } => println!("移动到 ({}, {})", x, y),
// 匹配元组变体
Message::Color(r, g, b) => println!("颜色 RGB({}, {}, {})", r, g, b),
}
}
fn main() {
handle_direction(Direction::Up);
handle_message(Message::Echo(String::from("你好")));
handle_message(Message::Move { x: 10, y: 20 });
handle_message(Message::Color(255, 128, 0));
}匹配 Option 和 Result
rust
fn divide(a: f64, b: f64) -> Option<f64> {
if b == 0.0 {
None
} else {
Some(a / b)
}
}
fn parse_number(s: &str) -> Result<i32, String> {
s.parse::<i32>().map_err(|e| format!("解析失败:{}", e))
}
fn main() {
// 匹配 Option
let result = divide(10.0, 3.0);
match result {
Some(value) => println!("10 / 3 = {:.2}", value),
None => println!("不能除以零"),
}
match divide(5.0, 0.0) {
Some(v) => println!("结果:{}", v),
None => println!("除以零了"),
}
// 匹配 Result
match parse_number("42") {
Ok(n) => println!("解析成功:{}", n),
Err(e) => println!("错误:{}", e),
}
match parse_number("abc") {
Ok(n) => println!("解析成功:{}", n),
Err(e) => println!("错误:{}", e),
}
}多模式和或模式
用 | 在一个分支中匹配多个模式。
rust
fn main() {
let number = 4;
// 用 | 匹配多个值
match number {
1 | 3 | 5 | 7 | 9 => println!("{} 是奇数", number),
2 | 4 | 6 | 8 | 10 => println!("{} 是偶数", number),
_ => println!("不在 1-10 范围内"),
}
// 字符匹配
let ch = 'e';
match ch {
'a' | 'e' | 'i' | 'o' | 'u' => println!("'{}' 是元音", ch),
'a'..='z' => println!("'{}' 是辅音", ch),
_ => println!("不是小写字母"),
}
// 枚举的多变体匹配
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
let coin = Coin::Dime;
let is_silver = match coin {
Coin::Dime | Coin::Quarter => true,
Coin::Penny | Coin::Nickel => false,
};
println!("是银色的:{}", is_silver);
}解构匹配
match 可以解构元组、结构体、枚举等复合类型。
rust
struct Point {
x: i32,
y: i32,
}
fn main() {
// 解构元组
let pair = (0, -2);
match pair {
(0, 0) => println!("原点"),
(x, 0) => println!("在 X 轴上,x={}", x),
(0, y) => println!("在 Y 轴上,y={}", y),
(x, y) => println!("普通点 ({}, {})", x, y),
}
// 解构结构体
let point = Point { x: 3, y: 0 };
match point {
Point { x: 0, y: 0 } => println!("原点"),
Point { x, y: 0 } => println!("X 轴上,x={}", x),
Point { x: 0, y } => println!("Y 轴上,y={}", y),
Point { x, y } => println!("({}, {})", x, y),
}
// 解构引用
let numbers = vec![1, 2, 3];
match numbers.as_slice() {
[] => println!("空"),
[single] => println!("一个元素:{}", single),
[first, second] => println!("两个元素:{}, {}", first, second),
[first, .., last] => println!("多个元素,首:{},尾:{}", first, last),
}
}基本示例
简易的命令行计算器:
rust
enum Operation {
Add(f64, f64),
Subtract(f64, f64),
Multiply(f64, f64),
Divide(f64, f64),
Power(f64, f64),
}
fn calculate(op: &Operation) -> Result<f64, String> {
match op {
Operation::Add(a, b) => Ok(a + b),
Operation::Subtract(a, b) => Ok(a - b),
Operation::Multiply(a, b) => Ok(a * b),
Operation::Divide(a, b) => {
if *b == 0.0 {
Err(String::from("除数不能为零"))
} else {
Ok(a / b)
}
}
Operation::Power(base, exp) => Ok(base.powf(*exp)),
}
}
fn format_operation(op: &Operation) -> String {
match op {
Operation::Add(a, b) => format!("{} + {}", a, b),
Operation::Subtract(a, b) => format!("{} - {}", a, b),
Operation::Multiply(a, b) => format!("{} * {}", a, b),
Operation::Divide(a, b) => format!("{} / {}", a, b),
Operation::Power(a, b) => format!("{}^{}", a, b),
}
}
fn main() {
let operations = vec![
Operation::Add(10.0, 5.0),
Operation::Subtract(10.0, 5.0),
Operation::Multiply(3.0, 4.0),
Operation::Divide(10.0, 3.0),
Operation::Divide(10.0, 0.0),
Operation::Power(2.0, 10.0),
];
for op in &operations {
let expr = format_operation(op);
match calculate(op) {
Ok(result) => println!("{} = {:.4}", expr, result),
Err(e) => println!("{} -> 错误:{}", expr, e),
}
}
}常见问题
问题一:match 和 if-else if 链有什么区别?
| 对比项 | match | if-else if |
|---|---|---|
| 穷尽检查 | 强制(必须覆盖所有情况) | 不强制 |
| 模式匹配 | 支持解构、范围、绑定 | 只能用布尔条件 |
| 适合场景 | 枚举变体、精确值匹配 | 复杂条件组合 |
| 表达能力 | 模式语法丰富 | 任意布尔表达式 |
问题二:_ 通配符是什么?
_ 匹配任何值但不绑定。放在最后一个分支相当于"其他所有情况"。如果你的 match 已经穷尽了所有可能,就不需要 _。
问题三:match 的分支顺序重要吗?
重要。match 从上到下匹配,第一个匹配的分支被执行。如果一个宽泛的模式(如 _)放在前面,后面的具体模式永远不会被匹配到(编译器会警告 unreachable pattern)。
问题四:match 可以不返回值吗?
可以。如果不用 match 的返回值,每个分支执行语句就行,所有分支隐式返回 ()。
适用场景
- 枚举处理:匹配枚举的每个变体并提取关联数据
- Option/Result 处理:安全地解包可选值和错误
- 状态机:根据当前状态决定下一步操作
- 协议解析:根据消息类型做不同处理
- 精确值匹配:HTTP 状态码、命令字符串等
注意事项
match要求穷尽匹配,遗漏情况会编译报错- 分支从上到下匹配,宽泛模式要放在后面
match表达式所有分支的返回类型必须一致match会获取被匹配值的所有权(对于非 Copy 类型),需要时用引用- 每个分支的
=>后面如果是单个表达式不需要花括号,多行代码需要用{}包裹 - 不要忘了每个分支后面的逗号(最后一个分支的逗号可选)
总结
match 是 Rust 中最强大的控制流结构,它把一个值与一系列模式逐个对比,执行第一个匹配的分支。match 的核心优势是穷尽检查——编译器保证你不会遗漏任何情况。它支持字面量匹配、范围匹配、多模式(|)、解构(元组、结构体、枚举)等丰富的模式语法。match 最典型的用途是处理枚举变体和 Option/Result 类型。作为表达式,match 可以返回值,所有分支的返回类型必须一致。