跳到主要内容

Rust break 和 continue

提示
  1. 循环控制关键字：在 Rust 中，break 用于终止循环，而 continue 用于跳过当前迭代并继续下一次迭代。
  2. 嵌套循环和条件判断：在嵌套循环中，break 只终止其所在的内部循环，而 continue 会跳过当前内部循环的迭代。使用条件语句来控制这些关键字的执行。
  3. 示例和输出：示例代码展示了如何在 Rust 的 while、loop 和嵌套循环中使用 break 和 continue，以及它们的输出结果。

循环执行一段代码多次。然而，有时我们可能需要改变循环的流程，通过终止其执行或跳过一个迭代。

在这些情况下，我们使用 Rust 的 break 和 continue 来改变循环的正常执行流程。例如，

  • break - 终止循环
  • continue - 跳过循环的当前迭代，继续执行下一个迭代

Rust break​

在 Rust 中，我们使用 break 关键字来终止任何循环的执行。例如，

while n < 10 {
    break;
}

这里，无论循环条件（n < 10）如何，当 while 循环遇到 break 关键字时，就会结束。

示例：Rust 中的 break​

fn main() {
    let mut number = 0;

    // 循环从这里开始
    loop {
        number += 1;

        // 退出循环的条件
        if number > 5 {
            break;
        }

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

输出

1
2
3
4
5

这个程序使用 loop 表达式和 break 关键字打印前五个自然数。注意 break 关键字的使用，

if number > 5 {
    break;
}

当 number 变量在每次迭代中增加 1，达到 6 时，if 条件判断为 false，我们使用 break 关键字退出 loop。

注意： 用户需要定义循环退出的条件，否则循环可能会永远运行。你可以在 while 或 for 循环中以类似的方式使用 break 关键字。

Rust 中 break 关键字的工作原理​

Rust 中 continue 的工作原理

Rust 中带有嵌套循环的 break​

fn main() {
    let mut i = 1;

    // 外循环开始
    while i <= 5 {
        let mut j = 1;

        // 内循环开始
        while j <= 5 {
            print!("*");

            // 退出内循环的条件
            if j == 3 {
                // 终止内循环
                break;
            }

            j += 1;
        }

        println!("");

        i += 1;
    }
}

输出

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

在上面的示例中，我们在内部 while 循环的主体中使用了 break 关键字。

if j == 3 {
    // 终止内循环
    break;
}

当计数器变量 j 的值达到 3 时，内部 while 循环终止。因此，我们在屏幕的每一行上只看到三个星号（***）。

Rust 中的 continue​

在 Rust 中，我们使用 continue 语句来跳过任何循环的当前迭代，并移动到下一个迭代。例如，

while n < 10 {
    if n == 5 {
        continue;
    }
}

这里，无论循环条件（n<10）如何，当 while 循环遇到 continue 关键字时，它将跳过当前迭代。

示例：Rust 中的 continue​

fn main() {
    let mut number = 0;

    while number < 5 {
        number += 1;

        // 跳过迭代的条件
        if number == 3 {
            continue;
        }

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

输出

1
2
4
5

在这个示例中，我们使用 while 表达式来打印自然数。注意 continue 关键字的使用，

if number == 3 {
    continue;
}

这里，当 number 变量等于 3 时，我们跳过了这次迭代。因此，我们在输出中看不到 3。

在 Rust 中 continue 关键字的工作原理​

Rust 中带嵌套循环的 continue​

fn main() {
    let mut i = 1;

    // 开始外部循环
    while i <= 5 {
        let mut j = 1;

        // 开始内部循环
        while j <= 5 {
            j += 1;

            // 跳过内部循环的迭代条件
            if j == 3 {
                // 进入内部循环的下一次迭代
                continue;
            }

            print!("*");
        }

        println!("");

        i += 1;
    }
}

输出

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

这里，我们使用了 continue 关键字来跳过内部 while 循环的一次迭代。

if j == 3 {
    // 进入内部循环的下一次迭代
    continue;
}

当计数器变量 j 的值达到 3 时，我们跳过了当前内部 while 迭代，print!("*") 语句被跳过。因此，我们在屏幕的每一行上只看到四个星号（****）。

在 loop 中使用 break 和 continue​

我们也可以同时使用 break 和 continue 来控制程序的流程。例如，

fn main() {
    let mut number = 0;

    loop {
        number += 1;

        // 跳过迭代的条件
        if number == 3 {
            continue;
        }

        // 退出循环的条件
        if number > 5 {
            break;
        }

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

输出

1
2
4
5

这里，continue 关键字，

if number == 3 {
    continue;
}

跳过了当 number 变量的值为 3 时的迭代。

类似地，break 关键字，

if number > 5 {
    break;
}

如果 number 变量的值大于 5，则终止循环。

最后于 更新