观看B站软件工艺师杨旭的rust教程学习记录，有删减有补充

流程控制

if else

与条件相关联的代码块叫分支（arm）
if else是表达式，有返回值，每个分支的返回类型必须相同
如果使用了多于一个else if,最好使用match

fn main() {
    let number = 3;
    if number < 5 {
        println!("比五小");
    } else {
        println!("比五大");
    }
}

if else是表达式，有返回值,{}语句块最后一个表达式是5,所以返回了5的值

fn main() {
    let a = 2;
    let number = if a > 1 { 5 } else { 6 };
    println!("{}", number); //5
}

while（condition）循环

while条件循环

fn main() {
    let mut a = 1;
    while a != 10 {
        a += 1;
        print!("{}", a);//2345678910
    }
}

loop循环

和while(true)一样,但while可以使用其他条件，loop循环只能在break停止，while可以在条件不满足时停止

fn main() {
    let mut n = 1;
    loop {
        if n > 50 {
            break;
        }
        if n % 2 == 0 {
            println!("偶数{}",n);
        }
        n += 1;
    }
}

循环标签

多层循环直接break到最外层循环，以下例子从5递减到4跳出最内层循环，再次进入最内层循环递减到2结束循环，最内层循环进入两次

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 5;
        loop {
            println!("剩余 = {remaining}");
            if remaining == 4 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }
        count += 1;
    }
    println!("进入最内层循环= {count}");
}

for 循环

使用while、loop容易出错，使用for循环迭代访问不容易出现越界的情况
for里面的i不需要自己声明，for本质是迭代器iterator

fn main() {
    for i in 1..10 {
        //1~9 左闭右开
        print!("{}", i); //123456789
    }
    println!();
    for i in 1..=10 {
        //1~10 //想让它包含最后一个就加=
        print!("{}", i); //12345678910
    }
    println!();
    let list = [1, 2, 3, 4, 5, 6, 7, 8];
    for a in list.iter() {
        if *a > 5 {
            break; //跳出循环
        }
        print!("{}", a); //12345
    }
    println!();

    let str = "hello world";
    for char in str.chars() {
        print!("|{}", char); //|h|e|l|l|o| |w|o|r|l|d
    }
}

倒转遍历

fn main(){
    for number in (1..4).rev(){
        print!("{}",number);//321
    }
}

match 模式匹配

类似于swich case

fn main() {
    let number = 12;
    match number {
        // 模式为单个值
        0 => println!("匹配到1"),
        2 => println!("匹配到2"),
        // 模式为Range
        1..=3 => println!("匹配到1～3"),
        // 模式为 多个值
        5 | 6 | 9 => println!("匹配到5或6或9"),
        // 绑定模式，将模式中的值绑定给一个变量，供右边执行代码使用
        n @ 12 => println!("匹配到的值为：{}", n),//匹配到的值为：12
        // _ 通配符处理剩余情况
        _ => println!("没有匹配值"),
    }
}

mtach匹配必须穷举所有的肯可能
- None => None;
- _ => ()

使用{}添加语句块

fn main() {
    let number = 1;
    match number {
        0 => println!("匹配到0"),
        1 => {
            println!("还可以用{{}}多加几条语句");
            let a = 1;
            let b = 2;
            println!("{}", a + b);
        }
        _ => println!("没有匹配到值"),
    }
}

匹配守卫

听起来很高大上，其实就是再加一层流程控制来判断是不是在这个条件内，如if n > 5 && n < 10

fn main() {
    let number = 7;
    match number {
        1 | 2 | 3 => println!("匹配到1或2或3"),
        n if n > 5 && n < 10 => println!("数字在5～10之间"),
        _ => println!("没有匹配到数字"),
    }
}

if let 模式匹配

只有一个需要被匹配可以简化用if let,要么匹配要么不匹配，不需要穷举，可以加else来穷举没有匹配到的情况,还可以加else if let继续匹配

fn main() {
    let v = 1;
    if let 1 = v {
        //要匹配的值放在前面，和变量绑定区分开
        println!("匹配到值")
    }
}

对于while和loop循环使用if let，Some(x)代表可能出现的值，pop向量未空则返回None值，然后break

fn main() {
    let mut v1 = vec![1, 2, 3];
    loop {
        match v1.pop() {
            Some(x) => println!("{}", x),//3 2 1
            None => break,
        }
    }

    let mut v2 = vec![1, 2, 3];
    while let Some(x) = v2.pop() {
        println!("{}", x);//3 2 1
    }
}

while let

只要匹配就循环

fn main() {
    // 创建一个包含一些元素的向量
    let mut stack = vec![1, 2, 3, 4, 5];
    // 使用 `while let` 从向量中逐个弹出元素
    while let Some(top) = stack.pop() {
        println!("取值: {}", top);
    }
    println!("所有值都已取出！");
}

Rust简明教程第二章-流程控制