【Rust】分支语句详解

在 Rust 中，分支语句用于根据条件执行不同的代码路径。Rust 主要提供以下几种分支结构：

1. if 语句

最基本的条件分支，与大多数语言类似：

fn main() {
    let number = 7;

    if number < 5 {
        println!("条件为真");
    } else {
        println!("条件为假");
    }
}

多条件分支

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("能被4整除");
    } else if number % 3 == 0 {
        println!("能被3整除");
    } else {
        println!("其他情况");
    }
}

2. if 表达式（在 Rust 中是表达式！）

Rust 的 if 可以返回值，这使得它非常强大：

fn main() {
    let condition = true;
    
    // if 作为表达式使用
    let number = if condition {
        5  // 注意：没有分号
    } else {
        6  // 两个分支必须返回相同类型
    };
    
    println!("number 的值为: {}", number);
}

3. match 表达式

match 是 Rust 中最强大的分支语句，类似于其他语言的 switch，但功能更强大：

fn main() {
    let value = 3;

    match value {
        1 => println!("一"),
        2 => println!("二"),
        3 => println!("三"),
        _ => println!("其他数字"), // _ 是通配符
    }
}

match 返回值的例子：

fn main() {
    let number = 2;
    
    let description = match number {
        1 => "一",
        2 => "二",
        3 => "三",
        _ => "其他",
    };
    
    println!("{}", description);
}

范围匹配

fn main() {
    let age = 25;
    
    match age {
        0..=18 => println!("未成年"),
        19..=60 => println!("成年"),
        _ => println!("老年"),
    }
}

模式匹配（解构）

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!("退出"),
        Message::Move { x, y } => println!("移动到 ({}, {})", x, y),
        Message::Write(text) => println!("写入: {}", text),
    }
}

4. if let 语法糖

用于处理只关心一种匹配情况时的简化写法：

fn main() {
    let some_option_value = Some(3);
    
    // 传统 match 写法
    match some_option_value {
        Some(3) => println!("值是3"),
        _ => (),
    }
    
    // 使用 if let 简化
    if let Some(3) = some_option_value {
        println!("值是3");
    }
}

结合 else

fn main() {
    let some_value: Option<i32> = None;
    
    if let Some(x) = some_value {
        println!("值是: {}", x);
    } else {
        println!("没有值");
    }
}

5. while let 循环匹配

类似于 if let，但在循环中使用：

fn main() {
    let mut stack = Vec::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);
    
    // 只要 pop 返回 Some，就继续循环
    while let Some(top) = stack.pop() {
        println!("{}", top);
    }
}

重要特点

1. 完备性检查 ：match 必须处理所有可能情况
2. 模式绑定：可以直接在分支中提取值
3. 守卫条件：可以在模式后添加额外的条件检查

match number {
    x if x < 0 => println!("负数"),
    0 => println!("零"),
    x if x > 0 => println!("正数"),
    _ => unreachable!(), // 实际上不会执行到这里
}

这些分支语句使 Rust 的模式匹配功能非常强大，是 Rust 语言的核心特性之一。