@ 绑定语法 ​

什么是 @ 绑定 ​

@ 绑定(读作 "at binding")让你在模式匹配中同时做两件事:用模式检查值的结构,同时把匹配到的值绑定到一个变量上。当你既需要检查值是否在某个范围或符合某个模式,又需要在分支中使用这个值时,@ 就派上用场了。

语法是:变量名 @ 模式

rust
fn main() {
    let age = 25;

    match age {
        // 检查 age 是否在 0..=17 范围内,同时把值绑定到 a
        a @ 0..=17 => println!("{}岁,未成年", a),
        // 检查是否在 18..=59 范围内,同时绑定到 a
        a @ 18..=59 => println!("{}岁,成年", a),
        // 60 及以上绑定到 a
        a @ 60.. => println!("{}岁,老年", a),
        // 这个分支不会到达,但为了穷尽性(负数)
        a => println!("{}岁,无效年龄", a),
    }
}

为什么需要 @ 绑定 ​

没有 @ 的时候,范围模式匹配无法直接获取匹配到的具体值。

rust
fn main() {
    let num = 42;

    // 不用 @:能匹配范围,但不知道具体值
    match num {
        1..=50 => println!("1 到 50 之间"),  // 无法打印具体是多少
        _ => println!("其他"),
    }

    // 用变量绑定:能获取值,但无法限定范围
    match num {
        n => println!("值是 {}", n),  // 匹配一切,无法限定范围
    }

    // 用 @:既限定范围,又获取值
    match num {
        n @ 1..=50 => println!("{} 在 1 到 50 之间", n),
        n @ 51..=100 => println!("{} 在 51 到 100 之间", n),
        n => println!("{} 超出范围", n),
    }
}

@ 与枚举结合 ​

rust
enum Message {
    Hello { id: i32 },
    Goodbye,
}

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

    match msg {
        // 匹配 Hello 变体,且 id 在 3..=7 范围内,同时把 id 值绑定到 id_value
        Message::Hello { id: id_value @ 3..=7 } => {
            println!("找到范围内的 ID:{}", id_value);
        }
        // 匹配 Hello 变体,id 在 10..=12 范围
        Message::Hello { id: id_value @ 10..=12 } => {
            println!("找到另一个范围的 ID:{}", id_value);
        }
        // 匹配其他 Hello
        Message::Hello { id } => {
            println!("其他 ID:{}", id);
        }
        Message::Goodbye => println!("再见"),
    }
}

@ 与 Option/Result 结合 ​

rust
fn main() {
    let values = vec![Some(3), Some(15), None, Some(7), Some(50)];

    for val in &values {
        match val {
            // 匹配 Some,且内部值在 1..=10 范围
            Some(n @ 1..=10) => println!("小数字:{}", n),
            // 匹配 Some,且内部值在 11..=100 范围
            Some(n @ 11..=100) => println!("大数字:{}", n),
            // 匹配其他 Some
            Some(n) => println!("超大数字:{}", n),
            None => println!("无值"),
        }
    }

    // @ 绑定整个 Some 变体
    let maybe = Some(42);
    match maybe {
        // 把整个 Some(42) 绑定到 s,同时检查内部值
        s @ Some(42) => println!("找到了特殊值:{:?}", s),
        Some(n) => println!("其他值:{}", n),
        None => println!("空"),
    }
}

@ 与结构体模式 ​

rust
#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn classify_point(p: &Point) {
    match p {
        // x 在 -10..=10 范围内,y 也在 -10..=10 范围内
        Point { x: x_val @ -10..=10, y: y_val @ -10..=10 } => {
            println!("原点附近:({}, {})", x_val, y_val);
        }
        // x 为正,y 为正
        Point { x: x_val @ 1.., y: y_val @ 1.. } => {
            println!("第一象限远处:({}, {})", x_val, y_val);
        }
        point => {
            println!("其他位置:{:?}", point);
        }
    }
}

fn main() {
    classify_point(&Point { x: 3, y: 5 });
    classify_point(&Point { x: 50, y: 30 });
    classify_point(&Point { x: -20, y: 10 });
}

基本示例 ​

HTTP 状态码分类器:

rust
fn classify_status(code: u16) -> &'static str {
    match code {
        // 信息响应
        c @ 100..=199 => {
            println!("  信息状态码:{}", c);
            "信息响应"
        }
        // 成功
        c @ 200..=299 => {
            println!("  成功状态码:{}", c);
            "成功"
        }
        // 重定向
        c @ 300..=399 => {
            println!("  重定向状态码:{}", c);
            "重定向"
        }
        // 客户端错误
        c @ 400..=499 => {
            println!("  客户端错误:{}", c);
            "客户端错误"
        }
        // 服务端错误
        c @ 500..=599 => {
            println!("  服务端错误:{}", c);
            "服务端错误"
        }
        c => {
            println!("  未知状态码:{}", c);
            "未知"
        }
    }
}

fn main() {
    let codes = [200, 301, 404, 500, 201, 403, 502, 100, 999];

    for &code in &codes {
        let category = classify_status(code);
        println!("  {} -> {}\n", code, category);
    }
}

常见问题 ​

问题一:@ 绑定和守卫条件(if)有什么区别?

特性@ 绑定守卫条件 if
语法位置在模式内部在模式后面
用途绑定值 + 检查模式模式匹配后附加布尔条件
穷尽性参与穷尽性检查不参与穷尽性检查
灵活度只能用模式语法可以用任意布尔表达式

简单的范围检查用 @,复杂的条件判断用守卫。

问题二:@ 可以嵌套使用吗?

可以在不同层级使用多个 @。

rust
fn main() {
    let pair = (Some(5), Some(10));
    match pair {
        (Some(a @ 1..=10), Some(b @ 1..=10)) => {
            println!("两个都在 1-10 范围:{} 和 {}", a, b);
        }
        _ => println!("其他情况"),
    }
}

问题三:@ 绑定的变量在守卫条件中能用吗?

可以。@ 绑定的变量在同一分支的守卫条件和分支体中都可以使用。

rust
fn main() {
    let num = 15;
    match num {
        n @ 1..=100 if n % 3 == 0 => println!("{} 是 1-100 内的 3 的倍数", n),
        n @ 1..=100 => println!("{} 在 1-100 内", n),
        n => println!("{} 超出范围", n),
    }
}

适用场景 ​

  • 范围匹配并使用值:检查值是否在某个范围内,同时在分支中使用具体的值
  • 枚举字段的范围约束:匹配枚举变体的同时检查内部字段的范围
  • 嵌套结构中的值提取:在复杂模式中同时解构和绑定
  • 状态码/错误码分类:按范围分类的同时保留具体的码值

注意事项 ​

  • @ 的语法是 变量名 @ 模式,变量名在左,模式在右
  • @ 绑定的变量类型由模式决定
  • @ 可以和范围模式(1..=10)、字面量模式、枚举模式等组合使用
  • 简单的变量绑定不需要 @(直接写变量名就是绑定所有值)
  • @ 绑定的值在守卫条件和分支体中都可以使用
  • 如果只需要检查范围不需要具体值,直接用范围模式就够了,不需要 @

总结 ​

@ 绑定语法让你在模式匹配中同时完成模式检查和值绑定两个动作。典型用法是 n @ 1..=100——检查值是否在 1 到 100 之间,同时把匹配到的值绑定到变量 n。它可以和枚举模式、结构体模式、Option 等各种模式组合使用,也可以在守卫条件中引用绑定的变量。当你既需要限定值的范围又需要在分支中使用具体值时,@ 绑定就是最合适的工具。