跳到主要内容

If语句

  • 基本语法：if 语句可以根据条件执行不同的代码块，else if 和 else 可以处理多种情况。
  • 布尔条件：条件必须是布尔类型。
  • 表达式：if 语句可以作为表达式，返回一个值。

基本语法​

number 的值是 7，因此 else代码块会被执行，输出为：The number is greater than or equal to 5

fn main() {
    let number = 7;

    if number < 5 {
        println!("The number is less than 5");
    } else {
        println!("The number is greater than or equal to 5");
    }
}
if condition {
    // 当 condition 为 true 时执行的代码块
} else if another_condition {
    // 当 another_condition 为 true 时执行的代码块
} else {
    // 当以上条件都不满足时执行的代码块
}

if 语句作为表达式​

if 语句可以作为表达式，返回一个值。这在赋值和函数返回值时非常有用。

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

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

condition 为 true，因此 number 的值为 5，输出为：The value of number is: 5

循环

在 Rust 中，有三种主要的循环类型：loop、while 和 for。每种类型都有不同的用途和适用场景。

loop​

loop 会无限循环，直到明确退出。可以通过 break 语句跳出循环。

示例

fn main() {
   let mut count = 0;

   loop {
       count += 1;
       if count == 5 {
           break;
       }
   }

   println!("The loop ran {} times", count);
}

loop 会一直运行，直到 count 等于 5 时通过 break 跳出循环.输出为：The loop ran 5 times

while​

while 循环,每次都会检查条件，会在条件为 true 时反复执行代码块，当条件为 false 时结束。

如果要无限循环，使用loop

示例

fn main() {
    let mut number = 3;

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

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

在这个示例中，while 循环会在 number 不等于 0 时继续执行，输出为：

3!
2!
1!
LIFTOFF!!!

for​

for 循环用于遍历集合中的每个元素。它比 while 循环更简洁和安全，因为 for 循环不需要手动管理索引。

迭代范围​

for x in 0..10 {
	println!("{}", x); // x: i32
}

迭代数组​

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

    for element in a.iter() {
        println!("The value is: {}", element);
    }
}

在这个示例中，for 循环会遍历数组 a 中的每个元素，输出为：

The value is: 10
The value is: 20
The value is: 30
The value is: 40
The value is: 50

Enumerate方法​

  • enumerate 方法用于创建一个迭代器，该迭代器在迭代的同时生成一个索引和值对。
  • 适用于需要在迭代过程中访问索引和值的场景。

迭代范围​

for (i,j) in (5..10).enumerate() {
	println!("i = {} and j = {}", i, j);
}

对迭代器​

fn main() {
    let lines = "hello\nworld".lines();
    for (linenumber, line) in lines.enumerate() {
        println!("{}: {}", linenumber, line);
    }
}
  • 字符串："hello\nworld" 包含一个换行符 \n，将字符串分成两行。
  • .lines() 方法：将字符串分成一个个迭代的行，每行是一个字符串切片 &str。
  • enumerate 方法：将行迭代器转换成带索引的行迭代器，索引从 0 开始。
  • for 循环：遍历带索引的行，每次循环解构出索引和行内容。
  • println! 宏：格式化并打印索引和行内容。

输出

0: hello
1: world

提早结束迭代​

  • break：用于立即退出循环。
  • continue：用于跳过当前迭代并立即开始下一次迭代。

循环标签（Loop labels）​

  • 循环标签（Loop Labels）：用于在嵌套循环中指定哪个循环要被 break 或 continue 语句控制。

  • 带标签的 break：用于指定退出哪个循环。

  • 带标签的 continue：用于指定跳过哪个循环的当前迭代并继续下一次迭代。

  • 标签（Label）：标签是以单引号 ' 开头的名称，紧跟在标签名称之后的是一个冒号 :，用于标识循环。

基本语法​

'label_name: loop {
    // 循环体
}

示例​

带标签的 break​

在嵌套循环中，使用带标签的 break 可以指定退出哪个循环。

fn main() {
    'outer: for i in 1..5 {
        for j in 1..5 {
            if i == 2 && j == 2 {
                break 'outer;  // 退出外层循环
            }
            println!("i: {}, j: {}", i, j);
        }
    }
    println!("Exited the outer loop");
}

在 Rust 中，循环标签（loop labels）用于在嵌套循环中指定哪个循环要被 break 或 continue 语句控制。这在嵌套循环中尤为有用，可以避免误操作或意外退出错误的循环。

基本概念​

  • 标签（Label）：标签是以单引号 ' 开头的名称，紧跟在标签名称之后的是一个冒号 :，用于标识循环。
  • break 和 continue：可以使用标签来指定要跳出的循环或要继续的循环。

基本语法​

rust复制代码'label_name: loop {
    // 循环体
}

示例​

带标签的 break​

在嵌套循环中，使用带标签的 break 可以指定退出哪个循环。

fn main() {
    'outer: for i in 1..5 {
        for j in 1..5 {
            if i == 2 && j == 2 {
                break 'outer;  // 退出外层循环
            }
            println!("i: {}, j: {}", i, j);
        }
    }
    println!("Exited the outer loop");
}

在这个示例中，当 i 等于 2 且 j 等于 2 时，break 'outer 语句会退出外层循环。输出为：

i: 1, j: 1
i: 1, j: 2
i: 1, j: 3
i: 1, j: 4
i: 2, j: 1
i: 2, j: 2
Exited the outer loop

带标签的 continue​

在嵌套循环中，使用带标签的 continue 可以指定跳过哪个循环的当前迭代并继续下一次迭代。

fn main() {
    'outer: for i in 1..5 {
        for j in 1..5 {
            if i == 2 && j == 2 {
                continue 'outer;  // 跳过外层循环的当前迭代
            }
            println!("i: {}, j: {}", i, j);
        }
    }
}

在这个示例中，当 i 等于 2 且 j 等于 2 时，continue 'outer 语句会跳过外层循环的当前迭代。输出为：

i: 1, j: 1
i: 1, j: 2
i: 1, j: 3
i: 1, j: 4
i: 2, j: 1
i: 3, j: 1
i: 3, j: 2
i: 3, j: 3
i: 3, j: 4
i: 4, j: 1
i: 4, j: 2
i: 4, j: 3
i: 4, j: 4

带标签的 loop 循环​

在 loop 循环中使用标签可以控制嵌套的无限循环。

fn main() {
    let mut count = 0;

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

        'inner: loop {
            println!("remaining = {}", remaining);
            if remaining == 9 {
                break 'inner;  // 退出内层循环
            }
            if count == 2 {
                break 'counting_up;  // 退出外层循环
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {}", count);
}

在这个示例中，break 'inner 退出内层循环，break 'counting_up 退出外层循环。输出为：

count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2

结论​

  • loop：无限循环，除非使用 break 退出，适合需要重复执行直到某个条件满足的场景。

  • while：基于条件执行循环，适合条件未知的循环。

  • for：遍历集合中的每个元素，简洁、安全，避免手动管理索引，支持范围语法和迭代器。

  • enumerate：创建带索引和值对的迭代器，适用于需要在迭代过程中访问索引的场景。

  • 循环标签（Loop Labels）：在嵌套循环中指定具体的循环，结合 break 和 continue 使用。