模式守卫条件
什么是模式守卫
模式守卫(Match Guard)是在 match 分支的模式后面附加一个 if 条件。只有当模式匹配成功且守卫条件也为 true 时,这个分支才会被执行。守卫条件让你在模式匹配的基础上增加额外的筛选逻辑。
语法是:模式 if 条件 => 表达式
rust
fn main() {
let num = 4;
match num {
// 先匹配模式(任意 i32),再检查守卫条件
n if n < 0 => println!("{} 是负数", n),
n if n == 0 => println!("是零"),
n if n % 2 == 0 => println!("{} 是正偶数", n), // 匹配这个
n => println!("{} 是正奇数", n),
}
}基本用法
rust
fn main() {
let temperature = 28;
// 用守卫条件做范围判断
match temperature {
t if t < 0 => println!("{}度,极寒", t),
t if t < 10 => println!("{}度,寒冷", t),
t if t < 20 => println!("{}度,凉爽", t),
t if t < 30 => println!("{}度,舒适", t),
t if t < 40 => println!("{}度,炎热", t),
t => println!("{}度,极热", t),
}
// 守卫条件可以引用外部变量
let threshold = 100;
let value = 150;
match value {
v if v > threshold => println!("{} 超过阈值 {}", v, threshold),
v => println!("{} 在阈值 {} 以内", v, threshold),
}
}守卫条件与模式结合
守卫条件最强大的地方是和各种模式组合使用。
rust
fn main() {
// 和 Option 模式结合
let maybe_value: Option<i32> = Some(-5);
match maybe_value {
Some(v) if v > 0 => println!("正数:{}", v),
Some(v) if v == 0 => println!("零"),
Some(v) => println!("负数:{}", v), // 匹配这个
None => println!("无值"),
}
// 和元组模式结合
let point = (3, -4);
match point {
(x, y) if x > 0 && y > 0 => println!("第一象限"),
(x, y) if x < 0 && y > 0 => println!("第二象限"),
(x, y) if x < 0 && y < 0 => println!("第三象限"),
(x, y) if x > 0 && y < 0 => println!("第四象限"), // 匹配这个
(0, 0) => println!("原点"),
(x, 0) => println!("X轴上,x={}", x),
(0, y) => println!("Y轴上,y={}", y),
_ => unreachable!(),
}
// 和枚举模式结合
enum Command {
Move { x: i32, y: i32 },
Write(String),
Quit,
}
let cmd = Command::Move { x: 10, y: -5 };
match cmd {
Command::Move { x, y } if x == 0 && y == 0 => {
println!("移动到原点(无操作)");
}
Command::Move { x, y } if x.abs() + y.abs() > 100 => {
println!("移动距离太远:({}, {})", x, y);
}
Command::Move { x, y } => {
println!("移动到 ({}, {})", x, y);
}
Command::Write(ref text) if text.is_empty() => {
println!("空消息,忽略");
}
Command::Write(text) => {
println!("写入:{}", text);
}
Command::Quit => println!("退出"),
}
}守卫条件与多模式
守卫条件作用于整个 | 组合的多模式,而不是单个模式。
rust
fn main() {
let x = 4;
let is_even = true;
// 守卫条件 `if is_even` 同时作用于 4 | 5 | 6
// 即:(4 | 5 | 6) if is_even
match x {
4 | 5 | 6 if is_even => println!("匹配:4/5/6 且 is_even"),
_ => println!("不匹配"),
}
// 如果只想让守卫条件作用于某一个模式,没有直接语法
// 需要拆成单独的分支
match x {
4 if is_even => println!("是 4 且 is_even"),
5 => println!("是 5(不管 is_even)"),
6 => println!("是 6(不管 is_even)"),
_ => println!("其他"),
}
}守卫条件与穷尽性
带守卫条件的分支不参与穷尽性检查。编译器不会分析守卫条件是否覆盖了所有情况,所以通常需要一个没有守卫的兜底分支。
rust
fn main() {
let value: Option<i32> = Some(42);
// 即使逻辑上覆盖了所有情况,编译器也不认
// match value {
// Some(v) if v > 0 => println!("正"),
// Some(v) if v == 0 => println!("零"),
// Some(v) if v < 0 => println!("负"),
// None => println!("无"),
// // 编译错误:non-exhaustive patterns
// // 因为编译器不分析 if 条件的逻辑完备性
// }
// 正确做法:加一个无守卫的兜底
match value {
Some(v) if v > 0 => println!("正数:{}", v),
Some(v) if v == 0 => println!("零"),
Some(_) => println!("负数"), // 没有守卫,兜底所有剩余的 Some
None => println!("无值"),
}
}基本示例
用守卫条件实现一个简单的成绩评价系统:
rust
struct Student {
name: String,
score: f64,
attendance_rate: f64, // 出勤率,0.0 - 1.0
}
fn evaluate(student: &Student) -> &'static str {
match student {
// 出勤率太低直接不合格
s if s.attendance_rate < 0.6 => "不合格(出勤率不足)",
// 高分且高出勤
s if s.score >= 90.0 && s.attendance_rate >= 0.95 => "优秀",
// 高分但出勤一般
s if s.score >= 90.0 => "良好(出勤率待提高)",
// 中等分数
s if s.score >= 75.0 => "良好",
// 及格分数
s if s.score >= 60.0 => "及格",
// 低于60分
_ => "不及格",
}
}
fn main() {
let students = vec![
Student { name: String::from("张三"), score: 95.0, attendance_rate: 0.98 },
Student { name: String::from("李四"), score: 92.0, attendance_rate: 0.80 },
Student { name: String::from("王五"), score: 78.0, attendance_rate: 0.90 },
Student { name: String::from("赵六"), score: 55.0, attendance_rate: 0.85 },
Student { name: String::from("钱七"), score: 80.0, attendance_rate: 0.50 },
];
for s in &students {
println!("{}: {:.0}分, 出勤{:.0}% -> {}",
s.name, s.score, s.attendance_rate * 100.0, evaluate(s));
}
}常见问题
问题一:守卫条件和在分支体内用 if 有什么区别?
| 方式 | 写法 | 区别 |
|---|---|---|
| 守卫条件 | n if n > 0 => ... | 条件不满足时继续匹配下一个分支 |
| 分支内 if | n => { if n > 0 { ... } } | 已经进入了这个分支,不会回去匹配其他分支 |
守卫条件不满足时会"穿透"到下一个分支继续匹配,而分支体内的 if 不会。
问题二:守卫条件可以调用函数吗?
可以。守卫条件可以是任意返回 bool 的表达式,包括函数调用。
rust
fn is_prime(n: u32) -> bool {
if n < 2 { return false; }
for i in 2..=((n as f64).sqrt() as u32) {
if n % i == 0 { return false; }
}
true
}
fn main() {
let num = 7u32;
match num {
n if is_prime(n) => println!("{} 是质数", n),
n => println!("{} 不是质数", n),
}
}问题三:守卫条件有性能问题吗?
守卫条件中的表达式会在运行时计算。如果条件涉及复杂计算,每个不匹配的分支都可能触发计算。但通常来说,守卫条件都是简单的比较或判断,不会有性能问题。
适用场景
- 范围细分:在匹配到某个模式后,根据值的具体大小做进一步区分
- 多条件组合:模式匹配负责解构,守卫负责额外的逻辑条件
- 引用外部变量:守卫条件可以访问
match外部的变量 - 枚举变体内数据的条件过滤:先匹配变体,再用守卫检查关联数据
注意事项
- 带守卫的分支不参与穷尽性检查,通常需要兜底分支
- 守卫条件作用于整个
|多模式组合,不是单个模式 - 守卫条件不满足时会继续匹配下一个分支("穿透")
- 守卫条件中可以引用
match外部的变量 - 不要在守卫条件中放复杂的副作用代码(如 IO 操作),这会让代码难以理解
- 守卫条件适合作为模式匹配的补充,不要用它完全替代模式匹配
总结
模式守卫是在 match 分支的模式后面用 if 添加的额外条件。只有模式匹配成功且守卫条件为 true 时,分支才会执行;否则继续匹配下一个分支。守卫条件的核心价值是在模式匹配(解构数据)和布尔判断(检查条件)之间架起桥梁,让你用一个 match 表达式同时处理结构和值的判断。使用时要注意带守卫的分支不参与穷尽性检查,需要兜底分支来保证所有情况都被覆盖。