模式守卫条件 ​

什么是模式守卫 ​

模式守卫(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 => ...条件不满足时继续匹配下一个分支
分支内 ifn => { 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 表达式同时处理结构和值的判断。使用时要注意带守卫的分支不参与穷尽性检查,需要兜底分支来保证所有情况都被覆盖。