模式匹配 #

一、match 表达式 #

1.1 基本用法 #

rust 
fn main() {
    let number = 3;
    
    match number {
        1 => println!("一"),
        2 => println!("二"),
        3 => println!("三"),
        _ => println!("其他"),
    }
}

1.2 必须穷尽 #

match 必须覆盖所有可能：

rust 
fn main() {
    let number = 7;
    
    match number {
        1 => println!("一"),
        2 => println!("二"),
        3 => println!("三"),
        _ => println!("其他"),  // 必须有默认分支
    }
}

1.3 返回值 #

match 是表达式，可以返回值：

rust 
fn main() {
    let number = 3;
    
    let result = match number {
        1 => "一",
        2 => "二",
        3 => "三",
        _ => "其他",
    };
    
    println!("结果: {}", result);
}

二、匹配 Option #

2.1 基本匹配 #

rust 
fn main() {
    let some_value = Some(5);
    
    match some_value {
        Some(x) => println!("值: {}", x),
        None => println!("无值"),
    }
}

2.2 提取值 #

rust 
fn main() {
    let some_value = Some(5);
    
    let result = match some_value {
        Some(x) => x * 2,
        None => 0,
    };
    
    println!("结果: {}", result);
}

三、匹配 Result #

rust 
fn main() {
    let result: Result<i32, &str> = Ok(42);
    
    match result {
        Ok(value) => println!("成功: {}", value),
        Err(e) => println!("错误: {}", e),
    }
}

四、模式语法 #

4.1 字面量模式 #

rust 
fn main() {
    let x = 1;
    
    match x {
        1 => println!("一"),
        2 => println!("二"),
        _ => println!("其他"),
    }
}

4.2 变量绑定 #

rust 
fn main() {
    let x = Some(5);
    
    match x {
        Some(y) => println!("值: {}", y),
        None => println!("无值"),
    }
}

4.3 多重模式 #

rust 
fn main() {
    let x = 1;
    
    match x {
        1 | 2 => println!("一或二"),
        3..=5 => println!("三到五"),
        _ => println!("其他"),
    }
}

4.4 范围模式 #

rust 
fn main() {
    let x = 5;
    
    match x {
        1..=5 => println!("1到5"),
        6..=10 => println!("6到10"),
        _ => println!("其他"),
    }
}

4.5 解构结构体 #

rust 
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };
    
    match p {
        Point { x, y } => println!("({}, {})", x, y),
    }
    
    // 部分解构
    match p {
        Point { x, .. } => println!("x = {}", x),
    }
}

4.6 解构枚举 #

rust 
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let msg = Message::Move { x: 10, y: 20 };
    
    match msg {
        Message::Quit => println!("退出"),
        Message::Move { x, y } => println!("移动到 ({}, {})", x, y),
        Message::Write(text) => println!("文本: {}", text),
        Message::ChangeColor(r, g, b) => println!("颜色: ({}, {}, {})", r, g, b),
    }
}

4.7 解构元组 #

rust 
fn main() {
    let tuple = (1, 2, 3);
    
    match tuple {
        (1, y, z) => println!("第一个是1, y={}, z={}", y, z),
        (x, 2, z) => println!("第二个是2, x={}, z={}", x, z),
        _ => println!("其他"),
    }
}

4.8 忽略值 #

rust 
fn main() {
    let tuple = (1, 2, 3);
    
    match tuple {
        (first, _, _) => println!("第一个: {}", first),
    }
}

4.9 @ 绑定 #

rust 
fn main() {
    let x = 5;
    
    match x {
        n @ 1..=5 => println!("1到5: {}", n),
        n @ 6..=10 => println!("6到10: {}", n),
        _ => println!("其他"),
    }
}

五、匹配守卫 #

5.1 基本用法 #

rust 
fn main() {
    let x = Some(5);
    
    match x {
        Some(n) if n > 3 => println!("大于3: {}", n),
        Some(n) => println!("值: {}", n),
        None => println!("无值"),
    }
}

5.2 多条件 #

rust 
fn main() {
    let x = 5;
    let y = true;
    
    match x {
        n if n > 3 && y => println!("大于3且y为真: {}", n),
        n if n > 3 => println!("大于3: {}", n),
        _ => println!("其他"),
    }
}

六、if let #

6.1 简化匹配 #

rust 
fn main() {
    let some_value = Some(5);
    
    // 使用 match
    match some_value {
        Some(x) => println!("值: {}", x),
        _ => (),
    }
    
    // 使用 if let（更简洁）
    if let Some(x) = some_value {
        println!("值: {}", x);
    }
}

6.2 带 else #

rust 
fn main() {
    let some_value: Option<i32> = None;
    
    if let Some(x) = some_value {
        println!("值: {}", x);
    } else {
        println!("无值");
    }
}

七、while let #

rust 
fn main() {
    let mut stack = vec![1, 2, 3];
    
    while let Some(top) = stack.pop() {
        println!("弹出: {}", top);
    }
}

八、实践示例 #

8.1 状态机 #

rust 
enum State {
    Idle,
    Running,
    Paused,
    Stopped,
}

fn main() {
    let state = State::Running;
    
    match state {
        State::Idle => println!("空闲"),
        State::Running => println!("运行中"),
        State::Paused => println!("已暂停"),
        State::Stopped => println!("已停止"),
    }
}

8.2 计算器 #

rust 
enum Operator {
    Add,
    Sub,
    Mul,
    Div,
}

fn calculate(a: f64, op: Operator, b: f64) -> Option<f64> {
    match op {
        Operator::Add => Some(a + b),
        Operator::Sub => Some(a - b),
        Operator::Mul => Some(a * b),
        Operator::Div => {
            if b != 0.0 {
                Some(a / b)
            } else {
                None
            }
        }
    }
}

fn main() {
    let result = calculate(10.0, Operator::Add, 5.0);
    
    match result {
        Some(v) => println!("结果: {}", v),
        None => println!("计算错误"),
    }
}

8.3 解析命令 #

rust 
enum Command {
    Help,
    Quit,
    Echo(String),
    Move { x: i32, y: i32 },
}

fn execute(cmd: Command) {
    match cmd {
        Command::Help => println!("帮助信息"),
        Command::Quit => println!("退出"),
        Command::Echo(text) => println!("{}", text),
        Command::Move { x, y } => println!("移动到 ({}, {})", x, y),
    }
}

fn main() {
    execute(Command::Help);
    execute(Command::Echo(String::from("Hello")));
    execute(Command::Move { x: 10, y: 20 });
}

九、总结 #

本章学习了：

  • match 表达式
  • 模式语法
  • 匹配守卫
  • if let 简化匹配
  • while let 循环匹配
  • 各种解构模式

下一章，我们将学习函数。

最后更新：2026-03-27