Rust —— 流程控制

#Rust

1. 条件分支

if 表达式

Rust 不会像 Ruby、JavaScript 等语言一样自动将非布尔值转换为布尔值。
条件必须是布尔类型，否则会编译错误。

fn main() {
    let number = 3;
    // 这段代码会编译报错，因为整数 3 不能当作布尔值
    if number {
        println!("number was three");
    }
}

if 是一个 表达式（Expression），有返回值，可以赋值给变量。
注意：所有分支必须返回 同一类型 的值。

fn main() {
    let condition = true;

    // if 表达式的结果赋值给 number
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}

else if 表达式

Rust 会依次检查 if 条件，执行第一个为 true 的分支。
一旦匹配成功，后续的条件不会再检查。

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

⚠️ 如果 else if 太多，代码会变得复杂，此时可以用 模式匹配（Pattern Matching） 来简化。

2. 循环控制

loop 循环

loop 关键字表示无限循环，除非遇到 break 才会停止。

fn main() {
    loop {
        println!("again!");
    }
}

break 后面可以带返回值，作为 loop 表达式的结果。

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {result}");
}

循环标签：用于在多层循环中跳出外层循环。

fn main() {
    let mut count = 0;

    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break; // 跳出当前循环
            }
            if count == 2 {
                break 'counting_up; // 跳出外层循环
            }
            remaining -= 1;
        }

        count += 1;
    }

    println!("End count = {count}");
}

while 循环

while 更适合用在基于条件判断的循环。

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");
        number -= 1;
    }

    println!("LIFTOFF!!!");
}

while 遍历数组：

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);
        index += 1;
    }
}

⚠️ 缺点：数组大小若更改，可能导致 数组越界。

for 循环

for 更简洁、安全，不会发生数组越界。

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}

Hooray！流程控制学习完成！！！

#Rust