Rust学习笔记_02——数组
Rust学习笔记_03——元组
Rust学习笔记_04——引用

---

Rust学习笔记_05——控制流

控制流（1）

1. if表达式

1.1 基础

在Rust编程语言中，if表达式用于条件判断。它们允许你根据某个条件的真假来执行不同的代码块。Rust的if表达式语法简单但功能强大，支持else if和else子句，以及嵌套的if表达式。

if condition_1 {
    // 当条件为 true 时执行的代码块
} else if condition_2 {
    // 当condition_2 为 true 时执行的代码块
} else {
 	// 其他情况   
}

示例

fn main() {
    let number = 7;

    if number > 10 {
        println!("The number is greater than ten.");
    } else if number == 10 {
        println!("The number is ten.");
    } else if number < 10 && number > 5 {
        println!("The number is between five and ten.");
    } else {
        println!("The number is five or less.");
    }
}

1.2 表达式返回值

Rust中的if表达式是有返回值的，这意味着你可以将if表达式的结果赋值给变量

fn main() {
    let number = 10;

    let message = if number > 10 {
        "The number is greater than ten."
    } else if number == 10 {
        "The number is ten."
    } else {
        "The number is less than ten."
    };

    println!("{}", message);
}

1.3 嵌套的if表达式

fn main() {
    let number = 7;
    let is_positive = number > 0;

    if is_positive {
        if number > 5 {
            println!("The number is positive and greater than five.");
        } else {
            println!("The number is positive but less than or equal to five.");
        }
    } else {
        println!("The number is not positive.");
    }
}

1.4 注意事项

1. 条件必须是布尔类型：if表达式中的条件必须是布尔类型（bool）。如果条件不是布尔类型，Rust编译器会报错。

2. 代码块是必需的：与某些其他语言不同，Rust中的if表达式的大括号{}是必需的，即使代码块中只有一条语句。

2. Loop循环

2.1 基础

在Rust编程语言中，loop循环是一种基础且强大的控制流结构，它允许你创建一个无限循环，直到你在循环体内显式地使用break语句来退出。这种灵活性使得loop循环在处理不确定次数的迭代或需要等待某个条件成立时特别有用。

loop {
    // 循环体内的代码
    // 当需要退出循环时，使用 break 语句
}

示例

fn main() {
    let mut counter = 0;

    loop {
        println!("Counter is now: {}", counter);

        counter += 1;

        // 当计数器达到5时，退出循环
        if counter >= 5 {
            break;
        }
    }

    println!("Loop has ended.");
}

2.2 break 语句

在loop循环中，break语句用于立即退出循环。它还可以选择性地返回一个值，这个值可以被赋值给循环外部的变量

fn main() {
    let result = loop {
        // ... 一些计算或逻辑处理 ...

        // 假设在某个条件下，我们想要退出循环并返回一个值
        if /* 某个条件 */ {
            break 42; // 退出循环并返回42
        }
    };

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

示例

fn main() {
    // 声明一个变量来存储从loop中返回的值
    let result: Option<i32> = loop {
        // 模拟一些计算或逻辑处理
        println!("Searching for a number...");

        // 假设我们有一个条件，当满足时，我们想退出循环并返回一个值
        let number = get_random_number(); // 这是一个假设的函数，用于获取随机数

        // 检查这个数是否是我们想要的（比如，我们想要找到数字42）
        if number == 42 {
            // 当找到数字42时，退出循环并返回Some(42)
            break Some(42);
        }

        // 如果没有找到，继续循环（这里可以添加一些延迟或其他逻辑）
    };

    // 处理从loop中返回的结果
    match result {
        Some(value) => println!("Found the number: {}", value),
        None => println!("Did not find the number we were looking for."),
    }
}

// 这是一个假设的函数，用于模拟获取随机数
fn get_random_number() -> i32 {
    // 在实际代码中，这里会使用随机数生成器
    // 但为了示例，我们简单地返回一个递增的数字
    static MUT_COUNTER: std::sync::Mutex<i32> = std::sync::Mutex::new(0);
    let mut counter = MUT_COUNTER.lock().unwrap();
    *counter += 1;
    *counter
}

2.4 嵌套loop

你可以在loop循环内部再嵌套一个或多个loop循环，以处理更复杂的逻辑。嵌套循环的退出方式与单层循环相同，都是使用break语句。不过，在嵌套循环中，你可以通过标签（labels）来区分不同层级的break或continue语句（尽管Rust的loop、while和for循环本身不支持标签，但你可以通过其他方式如闭包或额外的变量来模拟这种行为）。

示例

fn main() {
    // 外部循环的控制变量
    let mut outer_loop_should_continue = true;

    // 外部loop循环
    loop {
        // 检查外部循环是否应该继续
        if !outer_loop_should_continue {
            break; // 退出外部循环
        }

        println!("Outer loop iteration");

        // 内部循环的控制变量
        let mut inner_loop_found = false;

        // 内部loop循环
        loop {
            println!("  Inner loop iteration");

            // 模拟一些条件检查
            let some_condition = check_some_condition(); // 假设的函数

            // 如果满足某个条件，想要退出内部循环并可能影响外部循环
            if some_condition {
                inner_loop_found = true; // 标记内部循环找到了条件
                break; // 退出内部循环
            }

            // 如果满足某个条件，想要同时退出外部和内部循环
            if should_exit_both_loops() {
                outer_loop_should_continue = false; // 标记外部循环应该停止
                break; // 由于是在内部循环中，这只会退出内部循环
                // 但由于外部循环的检查，它也会在下次迭代时退出
            }

            // 其他逻辑...
        }

        // 检查内部循环是否找到了我们想要的条件
        if inner_loop_found {
            // 根据内部循环的结果做进一步处理
            println!("Condition found in inner loop, processing...");

            // 如果需要，可以在这里设置条件来退出外部循环
            // outer_loop_should_continue = false; // 已经在某个条件中设置过了，这里可以省略
        } else {
            // 如果没有找到条件，可能需要做其他处理或继续外部循环
            println!("No condition found in inner loop, continuing outer loop...");

            // 可以根据需要添加其他逻辑来决定是否继续外部循环
            // 比如，可以设置一个计数器来限制外部循环的次数
        }

        // 在实际应用中，可能还有其他逻辑来决定是否继续外部循环
        // 这里为了示例简单，没有添加额外的条件检查
    }

    println!("All loops have ended.");
}

// 假设的函数，用于模拟条件检查
fn check_some_condition() -> bool {
    // 在实际代码中，这里会包含一些逻辑来检查条件
    // 为了示例，我们简单地返回一个交替的布尔值（模拟找到条件的概率）
    static MUT_COUNTER: std::sync::Mutex<i32> = std::sync::Mutex::new(0);
    let mut counter = MUT_COUNTER.lock().unwrap();
    *counter += 1;
    *counter % 2 == 0
}

// 假设的函数，用于模拟是否应该同时退出两个循环的条件
fn should_exit_both_loops() -> bool {
    // 在实际代码中，这里会包含一些逻辑来检查是否满足退出两个循环的条件
    // 为了示例，我们简单地返回false（不退出两个循环），或者可以根据需要修改
    false
}