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