Rust match 教程

不吃草的牛德

发布于 2026-04-23 11:45:18

620

文章被收录于专栏：RustRust

基本概念

match 是 Rust 中的强大模式匹配语法，类似于其他语言的 switch，但功能更强大。它允许你根据变量的值执行不同的代码分支，并且可以匹配复杂的数据结构。

基本用法

fn main() {
    let number = 3;

    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Other"), // _ 是通配符，匹配所有未被覆盖的情况
    }
}

输出：

Three

匹配范围与多个值

fn main() {
    let number = 7;

    match number {
        1 | 2 => println!("One or Two"), // 匹配 1 或 2
        3..=6 => println!("Three to Six"), // 匹配 3 到 6（包含 6）
        _ => println!("Other"),
    }
}

匹配枚举类型

Rust 的枚举和 `match` 搭配非常强大：

enum Direction {
    North,
    South,
    East,
    West,
}

fn main() {
    let dir = Direction::East;

    match dir {
        Direction::North => println!("Go North"),
        Direction::South => println!("Go South"),
        Direction::East => println!("Go East"),
        Direction::West => println!("Go West"),
    }
}

匹配带数据的枚举

枚举可以携带数据，`match` 可以解构这些数据

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

fn main() {
    let msg = Message::Move { x: 10, y: 20 };

    match msg {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => println!("Move to ({}, {})", x, y),
        Message::Write(text) => println!("Write: {}", text),
    }
}

绑定变量与守卫（if 条件）

你可以在分支中绑定变量，还可以加条件

let x = Some(5);

match x {
    Some(n) if n > 0 => println!("Positive: {}", n),
    Some(n) => println!("Non-positive: {}", n),
    None => println!("None"),
}

解构元组和结构体

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

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

    match p {
        Point { x: 0, y } => println!("On Y axis at {}", y),
        Point { x, y: 0 } => println!("On X axis at {}", x),
        Point { x, y } => println!("At ({}, {})", x, y),
    }
}

可返回值（表达式）

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

let number = 2;
let result = match number {
    1 => "one",
    2 => "two",
    _ => "other",
};
println!("Result: {}", result);

穷尽性检查

Rust 要求 `match` 必须覆盖所有可能情况，否则编译报错。这保证了代码的安全性。

常见错误

忘记写 `_` 分支：如果不是枚举且没有覆盖所有可能值，必须加 `_`。

分支类型不一致：所有分支必须返回相同类型。

实战例子：Option 和 Result

fn main() {
    let maybe_name = Some("Alice");
    match maybe_name {
        Some(name) => println!("Hello, {}!", name),
        None => println!("No name found"),
    }

    let res: Result<i32, &str> = Err("error");
    match res {
        Ok(val) => println!("Value: {}", val),
        Err(e) => println!("Error: {}", e),
    }
}

总结

`match` 是 Rust 的模式匹配工具，功能远超传统 `switch`。

可以匹配数字、枚举、结构体、元组等。

支持绑定变量、范围、守卫（if）、解构等高级用法。

必须穷尽所有可能分支，保证安全。

是表达式，可以返回值。

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2025-10-25，如有侵权请联系 cloudcommunity@tencent.com 删除

match