if

  1. fn main() {
  2.     let number = 3;
  4.     if number < 5 {
  5.         println!("condition was true");
  6.     } else {
  7.         println!("condition was false");
  8.     }
  9. }
另外值得注意的是代码中的条件 必须 是 bool 值。如果条件不是 bool 值，我们将得到一个错误。 
  1. fn main() {
  2.     let number = 3;
  4.     if number {
  5.         println!("number was three");
  6.     }
  7. }
  8. // 报错

else if

可以将 else if 表达式与 if 和 else 组合来实现多重条件。 
  1. fn main() {
  2.     let number = 6;
  4.     if number % 4 == 0 {
  5.         println!("number is divisible by 4");
  6.     } else if number % 3 == 0 {
  7.         println!("number is divisible by 3");
  8.     } else if number % 2 == 0 {
  9.         println!("number is divisible by 2");
  10.     } else {
  11.         println!("number is not divisible by 4, 3, or 2");
  12.     }
  13. }

在 let 语句中使用 if

  1. fn main() {
  2.     let condition = true;
  3.     let number = if condition {
  4.         5
  5.     } else {
  6.         6
  7.     };
  9.     println!("The value of number is: {}", number);
  10. }
整个 if 表达式的值取决于哪个代码块被执行。这意味着 if 的每个分支的可能的返回值都必须是相同类型； 
  1. fn main() {
  2.     let condition = true;
  4.     let number = if condition {
  5.         5
  6.     } else {
  7.         "six"
  8.     };
  10.     println!("The value of number is: {}", number);
  11. }
  12. // 报错
if 代码块中的表达式返回一个整数，而 else 代码块中的表达式返回一个字符串。这不可行，因为变量必须只有一个类型。Rust 需要在编译时就确切的知道 number 变量的类型，这样它就可以在编译时验证在每处使用的 number 变量的类型是有效的。Rust 并不能够在 number 的类型只能在运行时确定的情况下工作；这样会使编译器变得更复杂而且只能为代码提供更少的保障，因为它不得不记录所有变量的多种可能的类型。

使用循环重复执行

Rust 有三种循环：loop、while 和 for。

loop

  1. fn main() {
  2.     loop {
  3.         println!("again!");
  4.     }
  5. }

从循环返回

  1. fn main() {
  2.     let mut counter = 0;
  4.     let result = loop {
  5.         counter += 1;
  7.         if counter == 10 {
  8.             break counter * 2; // 类似return显式退出
  9.         }
  10.     };
  12.     println!("The result is {}", result);
  13. }

while条件循环

  1. fn main() {
  2.     let mut number = 3;
  4.     while number != 0 {
  5.         println!("{}!", number);
  7.         number = number - 1;
  8.     }
  10.     println!("LIFTOFF!!!");
这种结构消除了很多使用 loop、if、else 和 break 时所必须的嵌套，这样更加清晰。当条件为真就执行，否则退出循环。

for

  1. fn main() {
  2.     let a = [10, 20, 30, 40, 50];
  3.     let mut index = 0;
  5.     while index < 5 {
  6.         println!("the value is: {}", a[index]);
  8.         index = index + 1;
  9.     }
  10. }
  12. // 但这个过程很容易出错；如果索引长度不正确会导致程序 panic。
  13. // 这也使程序更慢，因为编译器增加了运行时代码来对每次循环的每个元素进行条件检查。
  15. //作为更简洁的替代方案，可以使用 for 循环来对一个集合的每个元素执行一些代码。
  16. fn main() {
  17.     let a = [10, 20, 30, 40, 50];
  19.     for element in a.iter() {
  20.         println!("the value is: {}", element);
  21.     }
  22. }
  25. // 逆序遍历
  26. fn main() {
  27.     for number in (1..4).rev() {
  28.         println!("{}!", number);
  29.     }
  30.     println!("LIFTOFF!!!");
  31. }
  33. fn main() {
  34.     let a = [10, 20, 30, 40, 50];
  36.     for number  in (0..5).rev() {
  37.         println!("the value is: {}", a[number]);
  38.     }
  39. }