match 模式匹配 ​

什么是 match ​

match 是 Rust 中最强大的控制流结构,它把一个值和一系列模式逐个对比,执行第一个匹配的分支。match 要求穷尽所有可能——每个可能的值都必须被某个分支覆盖到,否则编译不通过。

rust
fn main() {
    let number = 3;

    match number {
        1 => println!("一"),
        2 => println!("二"),
        3 => println!("三"),    // 匹配这个
        4 => println!("四"),
        _ => println!("其他"), // _ 匹配所有剩余情况
    }
}

基本语法 ​

rust
fn main() {
    let x = 42;

    // match 也是表达式,可以返回值
    let description = match x {
        0 => "零",
        1..=9 => "个位数",
        10..=99 => "两位数",
        100..=999 => "三位数",
        _ => "更大的数",
    };
    println!("{} 是{}", x, description);

    // 每个分支可以是代码块
    let result = match x {
        0 => {
            println!("是零");
            0
        }
        n if n > 0 => {
            println!("{} 是正数", n);
            n * 2
        }
        _ => {
            println!("是负数");
            -1
        }
    };
    println!("结果:{}", result);
}

匹配枚举 ​

match 最经典的用法就是匹配枚举的各个变体。

rust
enum Direction {
    Up,
    Down,
    Left,
    Right,
}

enum Message {
    Quit,
    Echo(String),
    Move { x: i32, y: i32 },
    Color(u8, u8, u8),
}

fn handle_direction(dir: Direction) {
    match dir {
        Direction::Up => println!("向上移动"),
        Direction::Down => println!("向下移动"),
        Direction::Left => println!("向左移动"),
        Direction::Right => println!("向右移动"),
    }
}

fn handle_message(msg: Message) {
    match msg {
        // 匹配无数据的变体
        Message::Quit => println!("退出"),
        // 匹配带数据的变体,绑定内部值
        Message::Echo(text) => println!("回显:{}", text),
        // 匹配带命名字段的变体
        Message::Move { x, y } => println!("移动到 ({}, {})", x, y),
        // 匹配元组变体
        Message::Color(r, g, b) => println!("颜色 RGB({}, {}, {})", r, g, b),
    }
}

fn main() {
    handle_direction(Direction::Up);
    handle_message(Message::Echo(String::from("你好")));
    handle_message(Message::Move { x: 10, y: 20 });
    handle_message(Message::Color(255, 128, 0));
}

匹配 Option 和 Result ​

rust
fn divide(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 {
        None
    } else {
        Some(a / b)
    }
}

fn parse_number(s: &str) -> Result<i32, String> {
    s.parse::<i32>().map_err(|e| format!("解析失败:{}", e))
}

fn main() {
    // 匹配 Option
    let result = divide(10.0, 3.0);
    match result {
        Some(value) => println!("10 / 3 = {:.2}", value),
        None => println!("不能除以零"),
    }

    match divide(5.0, 0.0) {
        Some(v) => println!("结果:{}", v),
        None => println!("除以零了"),
    }

    // 匹配 Result
    match parse_number("42") {
        Ok(n) => println!("解析成功:{}", n),
        Err(e) => println!("错误:{}", e),
    }

    match parse_number("abc") {
        Ok(n) => println!("解析成功:{}", n),
        Err(e) => println!("错误:{}", e),
    }
}

多模式和或模式 ​

用 | 在一个分支中匹配多个模式。

rust
fn main() {
    let number = 4;

    // 用 | 匹配多个值
    match number {
        1 | 3 | 5 | 7 | 9 => println!("{} 是奇数", number),
        2 | 4 | 6 | 8 | 10 => println!("{} 是偶数", number),
        _ => println!("不在 1-10 范围内"),
    }

    // 字符匹配
    let ch = 'e';
    match ch {
        'a' | 'e' | 'i' | 'o' | 'u' => println!("'{}' 是元音", ch),
        'a'..='z' => println!("'{}' 是辅音", ch),
        _ => println!("不是小写字母"),
    }

    // 枚举的多变体匹配
    enum Coin {
        Penny,
        Nickel,
        Dime,
        Quarter,
    }

    let coin = Coin::Dime;
    let is_silver = match coin {
        Coin::Dime | Coin::Quarter => true,
        Coin::Penny | Coin::Nickel => false,
    };
    println!("是银色的:{}", is_silver);
}

解构匹配 ​

match 可以解构元组、结构体、枚举等复合类型。

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

fn main() {
    // 解构元组
    let pair = (0, -2);
    match pair {
        (0, 0) => println!("原点"),
        (x, 0) => println!("在 X 轴上,x={}", x),
        (0, y) => println!("在 Y 轴上,y={}", y),
        (x, y) => println!("普通点 ({}, {})", x, y),
    }

    // 解构结构体
    let point = Point { x: 3, y: 0 };
    match point {
        Point { x: 0, y: 0 } => println!("原点"),
        Point { x, y: 0 } => println!("X 轴上,x={}", x),
        Point { x: 0, y } => println!("Y 轴上,y={}", y),
        Point { x, y } => println!("({}, {})", x, y),
    }

    // 解构引用
    let numbers = vec![1, 2, 3];
    match numbers.as_slice() {
        [] => println!("空"),
        [single] => println!("一个元素:{}", single),
        [first, second] => println!("两个元素:{}, {}", first, second),
        [first, .., last] => println!("多个元素,首:{},尾:{}", first, last),
    }
}

基本示例 ​

简易的命令行计算器:

rust
enum Operation {
    Add(f64, f64),
    Subtract(f64, f64),
    Multiply(f64, f64),
    Divide(f64, f64),
    Power(f64, f64),
}

fn calculate(op: &Operation) -> Result<f64, String> {
    match op {
        Operation::Add(a, b) => Ok(a + b),
        Operation::Subtract(a, b) => Ok(a - b),
        Operation::Multiply(a, b) => Ok(a * b),
        Operation::Divide(a, b) => {
            if *b == 0.0 {
                Err(String::from("除数不能为零"))
            } else {
                Ok(a / b)
            }
        }
        Operation::Power(base, exp) => Ok(base.powf(*exp)),
    }
}

fn format_operation(op: &Operation) -> String {
    match op {
        Operation::Add(a, b) => format!("{} + {}", a, b),
        Operation::Subtract(a, b) => format!("{} - {}", a, b),
        Operation::Multiply(a, b) => format!("{} * {}", a, b),
        Operation::Divide(a, b) => format!("{} / {}", a, b),
        Operation::Power(a, b) => format!("{}^{}", a, b),
    }
}

fn main() {
    let operations = vec![
        Operation::Add(10.0, 5.0),
        Operation::Subtract(10.0, 5.0),
        Operation::Multiply(3.0, 4.0),
        Operation::Divide(10.0, 3.0),
        Operation::Divide(10.0, 0.0),
        Operation::Power(2.0, 10.0),
    ];

    for op in &operations {
        let expr = format_operation(op);
        match calculate(op) {
            Ok(result) => println!("{} = {:.4}", expr, result),
            Err(e) => println!("{} -> 错误:{}", expr, e),
        }
    }
}

常见问题 ​

问题一:match 和 if-else if 链有什么区别?

对比项matchif-else if
穷尽检查强制(必须覆盖所有情况)不强制
模式匹配支持解构、范围、绑定只能用布尔条件
适合场景枚举变体、精确值匹配复杂条件组合
表达能力模式语法丰富任意布尔表达式

问题二:_ 通配符是什么?

_ 匹配任何值但不绑定。放在最后一个分支相当于"其他所有情况"。如果你的 match 已经穷尽了所有可能,就不需要 _。

问题三:match 的分支顺序重要吗?

重要。match 从上到下匹配,第一个匹配的分支被执行。如果一个宽泛的模式(如 _)放在前面,后面的具体模式永远不会被匹配到(编译器会警告 unreachable pattern)。

问题四:match 可以不返回值吗?

可以。如果不用 match 的返回值,每个分支执行语句就行,所有分支隐式返回 ()。

适用场景 ​

  • 枚举处理:匹配枚举的每个变体并提取关联数据
  • Option/Result 处理:安全地解包可选值和错误
  • 状态机:根据当前状态决定下一步操作
  • 协议解析:根据消息类型做不同处理
  • 精确值匹配:HTTP 状态码、命令字符串等

注意事项 ​

  • match 要求穷尽匹配,遗漏情况会编译报错
  • 分支从上到下匹配,宽泛模式要放在后面
  • match 表达式所有分支的返回类型必须一致
  • match 会获取被匹配值的所有权(对于非 Copy 类型),需要时用引用
  • 每个分支的 => 后面如果是单个表达式不需要花括号,多行代码需要用 {} 包裹
  • 不要忘了每个分支后面的逗号(最后一个分支的逗号可选)

总结 ​

match 是 Rust 中最强大的控制流结构,它把一个值与一系列模式逐个对比,执行第一个匹配的分支。match 的核心优势是穷尽检查——编译器保证你不会遗漏任何情况。它支持字面量匹配、范围匹配、多模式(|)、解构(元组、结构体、枚举)等丰富的模式语法。match 最典型的用途是处理枚举变体和 Option/Result 类型。作为表达式,match 可以返回值,所有分支的返回类型必须一致。