Rust 编程语言 - 枚举和模式匹配

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 定义 ip 类型
enum IpAddrKind {
    V4,
    V6,
}

// 访问 枚举值 
let four = IpAddrKind::V4;

// 不同成员可以使用不同类型和数量的数据，可以定义为同一种类型
enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
}
let home = IpAddr::V4(127, 0, 0, 1);

let loopback = IpAddr::V6(String::from("::1"));

// 枚举上可以定义方法

impl IpAddr {
    fn call(&self){

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 可以看作是一种枚举类型，包含了None
// 在标准库中的定义形式
enum Option<T> {
    None,
    Some(T),
}

// 使用Option, 变量可为空的值
let absent_number: Option<i32> = None;
let y: Option<i8> = Some(5); 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

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

fn value_in_cents(coin: Coin) -> u8 {
    // 针对不同的场景，做不同处理
    match coin {
        Coin::Penny => {
            println!("Lucy Penny")
            1,
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

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

// 穷尽的例子

let dice_roll = 9;
match dice_roll {
    3 => add_fancy_hat(),
    7 => remove_fancy_hat(),
    other => move_player(other), // 通过other 确保穷尽
}

fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn move_player(num_spaces: u8) {}

// 忽略其他

let dice_roll = 9;
match dice_roll {
    3 => add_fancy_hat(),
    7 => remove_fancy_hat(),
    _ => reroll(),
}

fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn reroll() {}

1
2
3
4
5

    let config_max = Some(3u8);

    if let Some(max) = config_max {
        println!("The maximum is configured to be {}", max);
    }