模式匹配

模式匹配是 Rust 最强大的控制流工具之一。

match 表达式

fn main() {
    let number = 13;

    match number {
        1 => println!("一！"),
        2 | 3 | 5 | 7 | 11 => println!("这是质数"),
        13..=19 => println!("十几"),
        _ => println!("其他"),
    }
}

match 必须穷尽

fn main() {
    let x = 1;

    match x {
        1 => println!("一"),
        2 => println!("二"),
        _ => println!("其他"),  // 必须处理所有情况
    }
}

if let 模式

fn main() {
    let some_value = Some(3);

    // 只关心一种情况
    if let Some(3) = some_value {
        println!("三！");
    }

    // 等同于
    match some_value {
        Some(3) => println!("三！"),
        _ => (),
    }
}

while let 循环

fn main() {
    let mut stack = Vec::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);

    while let Some(top) = stack.pop() {
        println!("{}", top);
    }
}

解构

解构结构体

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

fn main() {
    let p = Point { x: 0, y: 7 };

    let Point { x, y } = p;
    println!("x = {}, y = {}", x, y);

    match p {
        Point { x: 0, y } => println!("在 y 轴上，y = {}", y),
        Point { x, y: 0 } => println!("在 x 轴上，x = {}", x),
        Point { x, y } => println!("其他位置: ({}, {})", x, y),
    }
}

解构枚举

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

fn process(msg: Message) {
    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),
    }
}

解构元组

fn main() {
    let tuple = (1, "hello", 4.5);

    let (x, y, z) = tuple;
    println!("{}, {}, {}", x, y, z);
}

模式守卫

fn main() {
    let num = Some(4);

    match num {
        Some(x) if x < 5 => println!("小于 5: {}", x),
        Some(x) => println!("{}", x),
        None => (),
    }
}

@ 绑定

enum Message {
    Hello { id: i32 },
}

fn main() {
    let msg = Message::Hello { id: 5 };

    match msg {
        Message::Hello { id: id_variable @ 3..=7 } => {
            println!("ID 在范围内: {}", id_variable)
        }
        Message::Hello { id: 10..=12 } => {
            println!("ID 在另一个范围内")
        }
        Message::Hello { id } => {
            println!("其他 ID: {}", id)
        }
    }
}

小结

• ✅ match 必须穷尽所有可能
• ✅ if let 用于只关心一种模式
• ✅ 可以解构结构体、枚举、元组
• ✅ 模式守卫添加额外条件
• ✅ @ 绑定在模式中创建变量