rust流程控制的具体使用

目录

• 一、分支
（一）if
（二）if let
（三）match
• 二、循环
（一）for
（二）while
（三）loop
（四）while let
• 三、循环标签
• 四、跳出循环
• （一）break
• （二）continue

if boolean_expression {
}

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

if boolean_expression {
} else {
}

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

fn main() {
     let condition = true;
     let number = if condition { 5 } else { 6 };
     println!("The value of number is: {number}");
}

fn main() {
     let condition = true;
     let number = if condition { 5 } else { "six" };
     println!("The value of number is: {number}");
}

if boolean_expression1 {
} else if boolean_expression2 {
} else {
}

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) ;
     }
}

IfLetExpression :
if let Pattern = Expression BlockExpression
(else ( BlockExpression | IfExpression | IfLetExpression ) )?

if let Pattern = Expression {
}

enum E {
     X(u8),
     Y(u8),
     Z(u8),
}
let v = E::Y(12);
if let E::X(n) | E::Y(n) = v {
     assert_eq!(n, 12);
}

if let Pattern = Expression {
} else {
}

let dish = ("Ham", "Eggs");
if let ("Bacon", b) = dish {
     println!("Bacon is served with {}", b);
} else {
     println!("No bacon will be served");
}

fn main() {
    let x = Some(3);
    let a = if let Some(1) = x { 1 } else { 5 };
    println!("{a}");
}

if let Pattern1 = Expression1 {
} else if let Pattern2 = Expression2 {
}else {
}

if let Pattern = Expression {
} else if boolean_expression{
}else {
}

let x = Some(3);
let a = if let Some(1) = x {
     1
} else if x == Some(2) {
     2
} else if let Some(y) = x {
     y
} else {
     -1
};
assert_eq!(a, 3);

if let PATS = EXPR {
     /* body */
} else {
     /*else */
}
等价于
match EXPR {
     PATS => { /* body */ },
     _ => { /* else */ }, // 如果没有else块，这相当于 `()`
}

let optional = Some(7);
match optional {
     Some(i) => {
         println!("This is a really long string and `{:?}`", i);
     },
     _ => {},     // 必须有，因为 `match` 需要覆盖全部情况。不觉得这行很多余吗？
};

fn main() {
     let number = Some(7);
     if let Some(i) = number {
         println!("Matched {:?}!", i);
     }
}

// 该枚举故意未注明 `#[derive(PartialEq)]`，
// 并且也没为其实现 `PartialEq`。这就是为什么下面比较 `Foo::Bar==a` 会失败的原因。
enum Foo {Bar}
fn main() {
     let a = Foo::Bar;
     // 变量匹配Foo::Bar
     if Foo::Bar == a {
         // ^-- 这就是编译时发现的错误。使用 `if let` 来替换它。
         println!("a is foobar");
     }
}

match variable_expression {
     pattern1 => {
     },
     pattern2 => {
         // 
     },
     _ => {
         // 默认
     }
};

fn main() {
     let x = 1;
     match x {
        1 => println!("one"),
        2 => println!("two"),
        3 => println!("three"),
        4 => println!("four"),
        5 => println!("five"),
        _ => println!("something else"),
     }
}

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

fn main() {
    let maybe_digit = Some(8);
    match maybe_digit {
         Some(x) if x < 10 => println!("digit < 10"),
         Some(x) => println!("digit >= 10"),
         None => panic!(),
    };
}

use std::cell::Cell;
let i = Cell::new(0i32);
match 1 {
     1 | _ if { i.set(i.get() + 1); false } => {}
     _ => {}
}
assert_eq!(i.get(), 2);

IteratorLoopExpression :
for Pattern in Expression BlockExpression

fn main(){
     for x in 1..11{
         println!("x is {}",x);
     }
}

fn main() {
     let a = [10, 20, 30, 40, 50];
     for element in a {
         println!("the value is: {element}");
     }
}

PredicateLoopExpression :
while Expression BlockExpression

fn main(){
     let mut x = 1;
     while x < 11{
         println!("inside loop x value is {}",x);
         x+=1;
     }
     println!("outside loop x value is {}",x);
}

loop {
}

fn main(){
     let mut x = 0;
     loop {
         x+=1;
         println!("x={}",x);
     }
}

PredicatePatternLoopExpression :
while let Pattern = Expression BlockExpression

let mut vals = vec![2, 3, 1, 2, 2];
while let Some(v @ 1) | Some(v @ 2) = vals.pop() {
     // 打印2, 2, 然后1
     println!("{}", v);
}

let mut x = vec![1, 2, 3];
while let Some(y) = x.pop() {
     println!("y = {}", y);
}
while let _ = 5 {
     println!("不可反驳模式总是会匹配成功");
     break;
}

while let PATS = EXPR {
     /* loop body */
}
等价于
loop {
     match EXPR {
         PATS => { /* loop body */ },
         _ => break,
     }
}

LoopLabel :
LIFETIME_OR_LABEL :

BreakExpression :
break LIFETIME_OR_LABEL? Expression?

let mut last = 0;
for x in 1..100 {
     if x > 12 {
         break;
     }
     last = x;
}
assert_eq!(last, 12);

'outer: loop {
     while true {
         break 'outer;
     }
}

fn main(){
     let mut x = 0;
     loop {
         x+=1;
         if x > 10 {
              break;
         }
         println!("x={}",x);
     }
}

let (mut a, mut b) = (1, 1);
let result = loop {
     if b > 10 {
         break b;
     }
     let c = a + b;
     a = b;
     b = c;
};
// 斐波那契数列中第一个大于10的值：
assert_eq!(result, 13);

ContinueExpression :
continue LIFETIME_OR_LABEL?

fn main(){
     for x in 1..11{
         if 5 == x {
             continue;
         }
         println!("x is {}",x);
     }
}

Rust个人学习小结之Rust的循环
Rust for循环语法糖背后的API场景分析
详解Rust中三种循环(loop,while,for)的使用