Rust入门-12-match控制流运算符

match 控制流运算符

match 允许我们将一个值与一系列的模式相比较，并根据相匹配的模式执行相应代码

模式可以是字面量、变量、通配符等等

enum Coin {      //美国硬币的类型
    Penny,       //1美分
    Nickel,      //5美分
    Dime,        //10美分
    Quarter,     //25美分
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

• 当 match 表达式执行时，它将结果值按顺序与每一个分支的模式相比较

  • 如果模式匹配了这个值，这个模式相关联的代码将被执行
  • 如果模式并不匹配这个值，将继续执行下一个分支

• 每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个 match 表达式的返回值

• match可以拥有任意数量的分支

分支代码短时，不需要大括号，若要在分支中运行多行代码时，可以使用大括号

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {              //使用大括号包含多行代码
            println!("Lucky penny!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

绑定值的模式

匹配分支可以绑定匹配的模式的部分值，即可以从枚举成员中提取值

#[derive(Debug)] //注解，便于打印调试
enum UsState {   //UsState 美国的州
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),   //这个分支关联了枚举类型
}

fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter(state) => {
            println!("State quarter from {:?}!", state);   // 输出state的值
            25
        }
    }
}
fn main() {
    value_in_cents(Coin::Quarter(UsState::Alaska));       //调用该函数后
}                                                         /*输出结果为  State quarter from Alaska
                  25
      */            

匹配 Option<T>

fn plus_one(x: Option<i32>) -> Option<i32> {  // 传入一个Option<T>,输出一个Option<T>
    match x {
        None => None,                         // 传入的为None，则输出None
        Some(i) => Some(i + 1),
    }
}

let five = Some(5);         
let six = plus_one(five);   //输出为Some(6)
let none = plus_one(None);  //输出为None

match匹配必须穷举所有的可能

Rust 中的匹配是穷举式的（exhaustive），必须穷举到最后的可能性来使代码有效

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {          //缺失了None，没有覆盖到所有可能的情况
    	Some(i) => Some(i + 1),
    }
} 

该代码不能编译

通配模式和 _ 占位符

不需要穷举所有的可能，只需要其中的一部分可能

let v = 0u8;       //v可能为0~255中的一个数字
match dice_roll {
    3 => println!("one"),        
    7 => println!("seven"),     //即只需要这两种情况
    other => (), //该分支行涵盖了其他所有的可能，且不执行其他操作（因为执行的为空元组）
}

可以使用 _ 代替other

不可以省略other或 _ ，会使程序报错（没有穷举所有的可能性）

let v = 0u8;       
match dice_roll {
    3 => println!("one"),        
    7 => println!("seven"),       
    _ => (), 
}