Rust 条件语句

条件语句是在程序执行过程中判断设定的条件是否成立，根据判断结果执行不同的操作。Rust 语言中条件语句有if 和 match 两种形式。

条件语句是编程语言中最常用的语句结构之一，它可以通过判断条件，改变代码的执行顺序，从而实现更多的功能。

绝大多数的编程语言都有着相同的条件语句，它们都是针对一个条件的真或假作出不同的选择，基本的流程图如下：

Rust 条件语句

 

1. Rust if 语句

1）if 语句的语法

if boolean_expression {
    // boolean_expression 为 true 时要执行的语句
    // statement(s) 
}

因此，if 语句运行流程：

  • 如果 boolean_expression 为 true ，则执行大括号里的 statement(s)。
  • 如果 boolean_expression 为 false ，则执行大括号后面的第一条语句。

2）if 语句的范例

我们写一个范例，使用 if 语句来模拟 如果数字大于 0 则输出 正数。

fn main(){
   let num:i32 = 5;
   if num > 0 {
      println!("正数");
   }
}

编译运行以上 Rust 代码，输出结果如下：

正数

 

2. Rust if else 语句

if 语句后面跟着一个可选的 else 语句，这种二选一的 if 语句，我们称之为 if else 语句。

1）if else 语句的语法

if boolean_expression {
   // 如果 boolean_expression 为真则执行这里的代码
} else {
   // 如果 boolean_expression 为假则执行这里的代码
}

2）if else 语句的范例

我们写一段代码，使用 if else 语句来判断一个数是否偶数或奇数，如果是偶数则输出 偶数 如果是奇数则输出 奇数

fn main() {
   let num = 12;
   if num % 2==0 {
      println!("偶数");
   } else {
      println!("奇数");
   }
}

编译运行以上 Rust 代码，输出结果如下：

偶数

 

3. Rust 嵌套 If 语句

嵌套 if 语句用于测试多种条件。

1）嵌套 if 语句的语法

if boolean_expression1 {
   // 当 boolean_expression1 为 true 时要执行的语句
} else if boolean_expression2 {
   // 当 boolean_expression2 为 true 时要执行的语句
} else {
   // 如果 boolean_expression1 和 boolean_expression2 都为 false 时要执行的语句
}

使用嵌套 if 语句，也就是 if...else if... 语句时需要牢记几个点：

  • 任何一个 if 或者嵌套 if 语句可以有 0 个或 1 个 else 语句，但 else 语句必须出现在 if else 后面，也就是出现在最后。
  • 任何一个 if 或者嵌套 if 语句可以有 0 个或多个 if else 语句，但所有的 if else 语句都必须出现在 else 语句之前。
  • 一旦某个 else if 中的条件 boolean_expression1 返回 true，那么后面的 else if 和 else 语句都不会运行。

2）嵌套 if 语句的范例

我们使用嵌套 if 语句来写一段代码，判断某个值是 大于、小于、等于 0。

fn main() {
   let num = 2 ;
   if num > 0 {
      println!("{} is positive",num);
   } else if num < 0 {
      println!("{} is negative",num);
   } else {
      println!("{} is neither positive nor negative",num) ;
   }
}

编译运行以上 Rust 代码，输出结果如下

2 is positive

 

4. Rust match 语句

match 语句用于检查 某个当前的值 是否匹配 一组/列值 中的某一个。

Rust 语句中的 match 表达式则类似于 C 语言中的 switch 语句。

1）match 语句的语法

Rust 中一个基本的 match 语句语法格式如下

match variable_expression {
   constant_expr1 => {
      // 语句;
   },
   constant_expr2 => {
      // 语句;
   },
   _ => {
      // 默认
      // 其它语句
   }
};

match 语句有返回值，它把 匹配值 后执行的最后一条语句的结果当作返回值。

let expressionResult = match variable_expression {
   constant_expr1 => {
      // 语句;
   },
   constant_expr2 => {
      // 语句;
   },
   _ => {
      // 默认
      // 其它语句
   }
};

我们来分析下上面这两个 match 语句的语法：

  1. 首先要说明的是 match 关键字后面的表达式不必括在括号中。也就是 variable_expression 不需要用一对 括号() 括起来。
  2. match 语句在执行的时候，会计算 variable_expression 表达式的值，然后把计算后的结果和每一个 constant_exprN 匹配，使用的是 全等于 也就是 === 来匹配。如果匹配成功则执行 => {} 里面的语句。
  3. 如果 variable_expression 表达式的值没有和任何一个 constant_exprN 匹配，那么它会默认匹配 _。

    因此，当没有匹配时，默认会执行 _ => {} 中的语句。

  4. match 语句有返回值，它把 匹配值 后执行的最后一条语句的结果当作返回值。
  5. _ => {} 语句是可选的，也就是说 match 语句可以没有它。
  6. 如果只有一条语句，那么每个 constant_expr2 => {} 中的 {} 是可以省略的。

2）match 语句的范例

看起来 match 语句有点复杂，我们直接拿几个范例来说明下

fn main(){
   let state_code = "MH";
   let state = match state_code {
      "MH" => {println!("Found match for MH"); "Maharashtra"},
      "KL" => "Kerala",
      "KA" => "Karnadaka",
      "GA" => "Goa",
      _ => "Unknown"
   };
   println!("State name is {}",state);
}

编译运行以上 Rust 代码，输出结果如下

Found match for MH
State name is Maharashtra

上面的范例中，state_code 对应着语法中的 variable_expression，MH、KL、KA、GA 对应这语法中的 constant_expr1 、constant_expr2 等等。

因为我们的 variable_expression 的值为 MH 和值为 MH 的第一个 constant_expr1 匹配，因此会执行 {println!("Found match for MH"); "Maharashtra"}。 然后将执行的最后一条语句的结果，也就是 "Maharashtra" 作为整个表达式的值返回。

这样，我们的 state 变量就被赋值为 Maharashtra。

上面这个范例是匹配的情况，如果不匹配，那么就会执行 _ => 语句

fn main(){
   let state_code = "MS";
   let state = match state_code {
      "MH" => {println!("Found match for MH"); "Maharashtra"},
      "KL" => "Kerala",
      "KA" => "Karnadaka",
      "GA" => "Goa",
      _ => "Unknown"
   };
   println!("State name is {}",state);
}

编译运行以上 Rust 代码，输出结果如下

Unknown
State name is Unknown

Rust 循环语句就是在指定条件为真的情况下，重复执行一组语句。Rust 语言中有三种循环语句：for 语句。一种有确定次数的循环。while 语句：一种在某些条件为真的情况下就会永远执行下去的循环。loop 语句：一种重复执行且永远不会结束的循环。三种语句都能实现循环功能，只不过侧重点不一样。