控制流

条件判断

if 表达式

if 表达式允许根据条件执行不同的代码分支.你提供一个条件并表示 "如果条件满足,运行这段代码;如果条件不满足,不运行这段代码."

• 条件必须是一个布尔表达式,即 true 或 false.编译器不会进行隐式类型转换,因此你不能直接使用数字或其他类型作为条件.

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true"); // 如果小于 5,输出 "condition was true"
    } else {
        println!("condition was false");  // 否则,输出 "condition was false"
    }
}

else if 分支

可以将 else if 表达式与 if 和 else 组合来实现多重条件.

• 逐个匹配条件,一旦找到满足条件的分支,其他分支将被忽略.

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");
    }
}

在 let 语句中使用 if

if 表达式可以直接在 let 语句中使用,这样你就可以根据条件来决定变量的值.

• if 的各个分支可能产生的结果值都必须是相同类型;否则编译器会报错.

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 }; // 如果 condition 为 true,number 的值为 5;否则为 6

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

循环

Rust 有三种循环:loop、while 和 for 循环.

loop 循环

loop 循环会一直执行,直到你显式地使用 break 语句来退出循环.

fn main() {
    loop {
        println!("again!"); // 这段代码会无限循环,输出 "again!"
        // break; // 使用 break 语句退出循环
    }
}

使用快捷键 Ctrl-C 来中断一个陷入无限循环的程序

从循环返回值

loop 循环可以返回一个值,这个值是通过 break 语句指定的.

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1; // 每次循环将 counter 增加 1

        if counter == 10 {
            break counter * 2; // 当 counter 等于 10 时,使用 break 返回 counter 的两倍
        }
    };

    println!("The result is {result}"); // 输出 "The result is 20"
}

循环标签

Rust 允许你为循环添加标签,这在嵌套循环中非常有用,可以指定要退出哪个循环.

fn main() {
    let mut count = 0;

    'counting_up: loop { // 外层循环,标签为 'counting_up
        println!("count = {count}");
        let mut remaining = 10;

        loop { // 内层循环
            println!("remaining = {remaining}");
            if remaining == 9 {
                break; // 退出内层循环
            }
            if count == 2 {
                break 'counting_up; // 退出外层循环
            }
            remaining -= 1; // 每次循环将 remaining 减少 1
        }

        count += 1; // 每次外层循环将 count 增加 1
    }

    println!("End count = {count}"); // 输出 "End count = 2"
}

while 循环

while 循环会一直执行,直到指定的条件不满足为止.

fn main() {
    let mut number = 3;

    while number != 0 { // 当 number 不等于 0 时,继续循环
        println!("{number}!"); // 输出当前的 number 值
        number -= 1; // 每次循环将 number 减少 1
    }

    println!("LIFTOFF!!!"); // 当循环结束时,输出 "LIFTOFF!!!"
}

while let 表达式

while let 表达式允许你在循环中同时进行模式匹配和条件判断.

fn main() {
    let mut stack = Vec::new();

    stack.push(1); // 将 1 压入栈
    stack.push(2); // 将 2 压入栈
    stack.push(3); // 将 3 压入栈

    while let Some(top) = stack.pop() { // 当 stack 不为空时,将栈顶元素弹出并赋值给 top
        println!("{top}"); // 输出当前的 top 值
    }
}

for 循环

for 循环用于迭代集合中的元素.Rust 提供了多种方式来创建迭代器.

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

    for element in a { // 迭代数组 a 中的每个元素
        println!("the value is: {element}"); // 输出当前的元素值
    }
}

使用 Range 迭代

Rust 提供了一个 Range 语法来生成一个数字序列,这在需要迭代一定范围内的数字时非常有用.

语法:

方法	说明
(start..end)	生成一个从 start 到 end - 1 的范围
(start..=end)	生成一个从 start 到 end 的范围
(start..end).rev()	生成一个从 end - 1 到 start 的范围,并使用 rev() 方法反转顺序

fn main() {
    for number in (1..4).rev() { // 迭代从 1 到 3 的数字,并使用 rev() 方法反转顺序
        println!("{number}!"); // 输出当前的 number 值
    }

    println!("LIFTOFF!!!"); // 当循环结束时,输出 "LIFTOFF!!!"
}