Rust 模式匹配

模式匹配是 Rust 中强大的特性，它允许我们根据值的结构进行匹配和处理。本章节将介绍 Rust 中的模式匹配。

match 语句

match 语句是 Rust 中最基本的模式匹配工具：

fn main() {
    let number = 3;
    
    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Other"),
    }
}

match 语句的返回值

match 语句可以返回值：

fn main() {
    let number = 3;
    
    let result = match number {
        1 => "One",
        2 => "Two",
        3 => "Three",
        _ => "Other",
    };
    
    println!("Result: {}", result);
}

模式绑定

可以在模式中绑定变量：

fn main() {
    let optional_number = Some(5);
    
    match optional_number {
        Some(x) => println!("Got a number: {}", x),
        None => println!("No number"),
    }
}

多模式匹配

可以使用 | 符号匹配多个模式：

fn main() {
    let number = 2;
    
    match number {
        1 | 2 | 3 => println!("Small number"),
        4 | 5 | 6 => println!("Medium number"),
        _ => println!("Large number"),
    }
}

范围匹配

可以使用 ..= 符号匹配范围：

fn main() {
    let number = 42;
    
    match number {
        1..=10 => println!("1-10"),
        11..=20 => println!("11-20"),
        21..=30 => println!("21-30"),
        _ => println!("Other"),
    }
}

if let 语句

if let 是 match 的简化形式，用于处理只有一个匹配分支的情况：

fn main() {
    let some_number = Some(5);
    
    if let Some(x) = some_number {
        println!("Number is: {}", x);
    } else {
        println!("No number");
    }
}

while let 语句

while let 用于在循环中处理 Option 类型：

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

for 循环中的模式

在 for 循环中也可以使用模式：

fn main() {
    let pairs = vec![(1, 2), (3, 4), (5, 6)];
    
    for (a, b) in pairs {
        println!("{} + {} = {}", a, b, a + b);
    }
}

函数参数中的模式

函数参数也可以使用模式：

fn print_coordinates(&(x, y): &(i32, i32)) {
    println!("x: {}, y: {}", x, y);
}

fn main() {
    let point = (3, 5);
    print_coordinates(&point);
}

结构体模式

可以匹配结构体的字段：

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

fn main() {
    let point = Point { x: 10, y: 20 };
    
    match point {
        Point { x, y } => println!("Point: ({}, {})", x, y),
    }
    
    // 匹配部分字段
    match point {
        Point { x, y: 20 } => println!("Point with y=20: x={}", x),
        _ => println!("Other point"),
    }
}

枚举模式

可以匹配枚举的变体：

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

fn main() {
    let message = Message::Write(String::from("Hello"));
    
    match message {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => println!("Move to ({}, {})", x, y),
        Message::Write(text) => println!("Write: {}", text),
        Message::ChangeColor(r, g, b) => println!("Change color to ({}, {}, {})", r, g, b),
    }
}

总结

• match 语句是 Rust 中最基本的模式匹配工具
• if let 是 match 的简化形式，用于处理只有一个匹配分支的情况
• while let 用于在循环中处理 Option 类型
• 模式可以用于 for 循环、函数参数等地方
• 可以匹配结构体、枚举等复杂类型
• 模式匹配支持多模式、范围匹配等高级特性

通过本章节的学习，你应该已经掌握了 Rust 中的模式匹配，这是 Rust 中非常强大的特性，可以帮助你编写更简洁、更安全的代码。