Rust while 循环

我们使用 while 循环来执行一个代码块，直到条件为 true。while 表达式的语法是

while condition {
    // code block
}

// code block outside while loop

在这里，while 循环在继续之前会先评估 条件。

如果 条件 计算为

• true - 将执行 while 循环内的代码块，然后再次评估条件
• false - 循环终止，将执行 while 循环外的代码块

---

示例：Rust while 循环

fn main() {
    let mut counter = 1;

    // usage of while loop
    while counter < 6 {
        println!("{}", counter);
        
        counter += 1;
    }
}

输出

1
2
3
4
5

在上面的示例中，我们有一个 条件

while counter < 6 {
    // code block
}

在这里，循环将一直运行，直到 counter 变量小于 6。在循环内部，我们将 counter 的值增加 1。

在第 5 次迭代后，counter 的值为 6，因此 条件 counter < 6 变为 false，循环终止。

注意：while 表达式通常与计数器变量结合使用，这些变量有助于在满足某些条件后退出循环。

Rust 中 while 表达式的工作原理

无限 while 循环

您可以使用 while 表达式编写一个永不结束的循环。让我们看一个例子，

fn main() {
    let counter = 1;

    // while loop with a condition that always evaluates to true
    while counter < 6 {
        println!("Loop forever!");
   }
}

输出

Loop forever!
Loop forever!
Loop forever!
.
.
.

此示例代码将无限期地打印“Loop forever!”，因为 条件 counter < 6 始终计算为 true。这是因为我们在循环内部从未增加 counter 变量的值。因此，此程序将一直运行，直到用户终止程序。

注意： 您可以使用 break 关键字来终止 Rust 中的任何类型的循环。

示例：使用 while 循环的乘法表

fn main() {
    // variable to print multiplication table for
    let i = 2;
    
    // counter variable that starts at 1
    let mut j = 1;
    
    // while loop that runs for 10 iterations
    while j <= 10 {
        // multiply i and j
        let mult = i * j;
        
        // print multiplication result on each iteration
        println!("{} * {} = {}", i, j, mult);

        // increase value of counter variable j
        j += 1;
    }
}

输出

2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18
2 * 10 = 20

嵌套 while 循环

我们可以在另一个 while 循环的函数体内使用 while 循环。这被称为嵌套 while 循环。嵌套 while 循环看起来像这样

while outer_condition {
    // outer code block 1

    while inner_condition {
        // inner code block
    }

    // outer code block 2
}

让我们使用嵌套的 while 循环打印一个模式，

fn main() {
    // outer loop counter
    let mut i = 1;
    
    // outer loop
    while i <= 5 {
        // inner loop counter
        let mut j = 1;
        
        // inner loop
        while j <= 5 {
            print!("*");
            
            // increase inner loop counter
            j += 1;
        }
        
        println!("");
        
        // increase outer loop counter
        i += 1;
    }
}

输出

*****
*****
*****
*****
*****

在上面的例子中：

• 外部 while 循环迭代 5 次
• 外部 while 循环内的内部 while 循环也迭代 5 次
• 内部 while 循环在每次迭代时打印一个星号 (*) → print!(*)
• 当计数器变量 j 达到 6 时，内部 while 循环停止，因为 内部条件 计算为 false
• 外部 while 循环在每次迭代时打印一个新行 → println!("")，然后进入下一次迭代，这将再次启动内部 while 循环
• 当计数器变量 i 达到 6 时，外部 while 循环停止，因为 外部条件 计算为 false