15.枚举enum.rs

//枚举类在 Rust 中并不像其他编程语言中的概念那样简单，但依然可以十分简单的使用

#[derive(Debug)]
enum Book {
    Papery,
    Electronic,
}

//如果你现在正在开发一个图书管理系统，你需要描述两种书的不同属性（纸质书有索书号，电子书只有 URL），你可以为枚举类成员添加元组属性描述
enum Book2 {
    Papery(u32),
    Electronic(String),
}

//如果你想为属性命名，可以用结构体语法
enum Book3 {
    Papery { index: u32 },
    Electronic { url: String },
}

fn main() {
    let book = Book::Papery;
    println!("{:?}", book);

    let pbook2 = Book2::Papery(1001);
    let ebook2 = Book2::Electronic(String::from("url://..."));

    let pbook3 = Book3::Papery { index: 1001 };
    let ebook3 = Book3::Electronic {
        url: String::from("url..."),
    };

    //switch 语法很经典，但在 Rust 中并不支持,Rust 通过 match 语句来实现分支结构
    //match 块也可以当作函数表达式来对待，它也是可以有返回值的,但是所有返回值表达式的类型必须一样！
    match ebook3 {
        Book3::Papery { index } => {
            println!("papery book {}", index);
        }
        Book3::Electronic { url } => {
            println!("Electronic book {}", url);
        }
    }

    //如果把枚举类附加属性定义成元组，在 match 块中需要临时指定一个名字
    enum Book4 {
        Papery(u32),
        Electronic { url: String },
    }
    let book = Book4::Papery(1001);
    match book {
        Book4::Papery(i) => {
            println!("{}", i);
        }
        Book4::Electronic { url } => {
            println!("{}", url);
        }
    }

    //match 除了能够对枚举类进行分支选择以外，还可以对整数、浮点数、字符和字符串切片引用（&str）类型的数据进行分支选择。
    //其中，浮点数类型被分支选择虽然合法，但不推荐这样使用，因为精度问题可能会导致分支错误
    //对非枚举类进行分支选择时必须注意处理例外情况，即使在例外情况下没有任何要做的事 . 例外情况用下划线 _ 表示：
    let t = "abc";
    match t {
        "abc" => println!("Yes"),
        _ => {}
    }

    //Option 是 Rust 标准库中的枚举类，这个类用于填补 Rust 不支持 null 引用的空白
    /*
        enum Option<T> {
            Some(T),
            None,
        }
    */
    let opt = Option::Some("Option_Some_str");
    match opt {
        Option::Some(something) => {
            println!("{}", something);
        }
        Option::None => {
            println!("opt is nothing");
        }
    }
    //如果你的变量刚开始是空值，你体谅一下编译器，它怎么知道值不为空的时候变量是什么类型的呢？所以初始值为空的 Option 必须明确类型
    let opt: Option<&str> = Option::None;
    match opt {
        Option::Some(something) => {
            println!("{}", something);
        }
        Option::None => {
            println!("opt is nothing");
        }
    }
    //由于 Option 是 Rust 编译器默认引入的，在使用时可以省略 Option:: 直接写 None 或者 Some()
    //Option 是一种特殊的枚举类，它可以含值分支选择
    let t = Some(64);
    match t {
        Some(64) => println!("Yes64"),
        Some(72) => println!("Yes72"),
        _ => println!("No"),
    }

    //普通match
    let i = 0;
    match i {
        0 => println!("zero"),
        _ => {}
    }
    //if let 语法
    let i = 0;
    if let 0 = i {
        println!("zero");
    }
    //可以在之后添加一个 else 块来处理例外情况。
    //if let 语法可以认为是只区分两种情况的 match 语句的"语法糖"（语法糖指的是某种语法的原理相同的便捷替代品）。
    let book = Book2::Electronic(String::from("url://..."));
    //if let Book2::Papery(index) = book {
    if let Book2::Electronic(index) = book {
        println!("Papery {}", index);
    } else {
        println!("Not papery book");
    }

    let t: Option<i32> = Option::None;
    println!("{:?}", t.ok_or("123"));
    let errr = t.ok_or("123");
}