枚举和模式匹配:

内容:

• 枚举基础
• 常用枚举Option
• match表达式
• if let:简洁处理格式的表达式

枚举(enumerations)

基础使用

enum IpAddrKind {
    V4,
    V6,
}
struct IpAddr {
    kind: IpAddrKind,
    address: String,
}

fn main() {
    let home = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
    };
    let loopback = IpAddr {
        kind: IpAddrKind::V6,
        address: String::from("::1"),
    };
}

改进版本1:

enum IpAddr {
    V4(String),
    V6(String),
}

fn main() {
    let home = IpAddr::V4(String::from("127.0.0.1"));
    let loopback = IpAddr::V6(String::from("::1"));
}

改进版本2:

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

fn main() {
    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6(String::from("::1"));
}

Note:ip太常见,在标准库中已经有定义

例子:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}
struct QuitMessage; // 类单元结构体
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // 元组结构体
struct ChangeColorMessage(i32, i32, i32); // 元组结构体

impl Message {
    fn call(&self) {
        // do something
    }
}

fn main() {
    let m = Message::Write(String::from("hello"));
    m.call();
}

Option枚举

一个普遍的应用场景:当调用一个函数之后,返回一个值,这个值要么有值,要么没有值

Option:标准库内置的一个枚举,表示一个值要么有值要么没有值

Null References: The Billion Dollar Mistake

当你实现一个功能,能用一种很简单的方式去实现;

Option在标准库中的定义:

enum Option<T> {
    Some(T),
    None,
}

基本使用:

fn main() {
    let some_number = Some(5);
    let some_string = Some("a string");
    let absent_number: Option<i32> = None;
}

match 控制流运算符

基本使用:

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

fn main() {
    let val = value_in_cents(Coin::Penny);
    println!("val = {:?}", val);
}

Option使用match表达式:

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        None => None,
        Some(i) => Some(i + 1),
    }
}

fn main() {
    let five = Some(5);
    let six = plus_one(five);
    let none = plus_one(None);
}

_通配符:

fn main() {
    let some_u8_value = 0u8;
    match some_u8_value {
        1 => println!("one"),
        3 => println!("three"),
        5 => println!("five"),
        7 => println!("seven"),
        _ => (),
    }
}

if let简写match表达式:

当只关心其中的某种情况时,用if let来简写

fn main() {
    let some_u8_value = Some(0u8);
    match some_u8_value {
        Some(3) => println!("three"),
        _ => (),
    }

    // if let来简写
    if let Some(3) = some_u8_value {
        println!("three");
    }
}