Rust入门之枚举与模式匹配

枚举

枚举允许我们列举一系列所有可能的值来定义一个类型

enum

定义一个简单的例子

fn main() {
    let ipv4 = IpAddressType::IpV4;
    let ipv6 = IpAddressType::IpV6;
    rout(ipv4);
    rout(ipv6);
}

fn rout(ip_address: IpAddressType){}

enum IpAddressType{
    IpV4,
    IpV6
}

将数据绑定在枚举的变体中

fn main() {
    let ipv4 = IpAddressType::IpV4(String::from("127.0.0.1"));
    let ipv6 = IpAddressType::IpV6(String::from("::1"));
    rout(ipv4);
    rout(ipv6);
}

fn rout(ip_address: IpAddressType){}

enum IpAddressType{
    IpV4(String),
    IpV6(String)
}

IPv4地址特殊，也可以变换成这样

fn main() {
    let ipv4 = IpAddressType::IpV4(127,0,0,1);
    let ipv6 = IpAddressType::IpV6(String::from("::1"));
    rout(ipv4);
    rout(ipv6);
}

fn rout(ip_address: IpAddressType){}

enum IpAddressType{
    IpV4(u8,u8,u8,u8),
    IpV6(String)
}

我们可以在枚举变体中使用任意类型的数据，比如还可以用struct

fn main() {
    let ipv4 = IpAddressType::IpV4(IpAddress{
        name:String::from("ipv4"),
        address:String::from("127.0.0.1")
    });
    let ipv6 = IpAddressType::IpV6(IpAddress{
        name:String::from("ipv6"),
        address:String::from("::1")
    });
    rout(ipv4);
    rout(ipv6);
}

fn rout(ip_address: IpAddressType){}

enum IpAddressType{
    IpV4(IpAddress),
    IpV6(IpAddress)
}

struct IpAddress{
    name: String,
    address:String
}

为枚举定义方法，使用impl关键字，此处用到了match，match在后续会讲到

fn main() {
    let ipv4 = IpAddressType::IpV4(IpAddress{
        name:String::from("ipv4"),
        address:String::from("127.0.0.1")
    });
    let ipv6 = IpAddressType::IpV6(IpAddress{
        name:String::from("ipv6"),
        address:String::from("::1")
    });
    ipv4.go();
    ipv6.go();
}

enum IpAddressType{
    IpV4(IpAddress),
    IpV6(IpAddress)
}
impl IpAddressType{
    fn go(&self){
        match self {
            IpAddressType::IpV4(v) => {
                println!("我是：{}，我要跳转的地址是：{}",v.name,v.address)
            }
            IpAddressType::IpV6(v) => {
                println!("我是：{}，我要跳转的地址是：{}",v.name,v.address)
            }
        }
    }
}

Option<T>

在其他语言中，NULL是一个值，它表示“没有值”，一个变量可以处于两种状态（空值(null)、非空）

所以Rust中有一个类似NULL的一个枚举Option<T>

标准库中定义如下

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

我们可以这样使用Option <T>

fn main() {

    let five = Some(5);
    let hello = Some("hello");
    let xx : Option<String> = None;
}

Option<T>与T是不同的，不能把Option<T>当成T，如果想使用Option<T>中的T，需要把Option<T>转为T。

fn main() {
    let v= 5;
    let five = Some(5);
    let y = match five {
        None => 0,
        Some(num) => num,
    };
    let x = v + y;
    println!("{}",x)
}

模式匹配

match

直接看例子

fn main() {
    let jiao = RMB::Jiao;
    let v = value(jiao);
    println!("结果：{}",v)
}

fn value(rmb:RMB)->i32{
    match rmb {
        RMB::Yuan => {1}
        RMB::Jiao => {10}
        RMB::Fen => {100}
    }
}

enum RMB{
    Yuan,
    Jiao,
    Fen,
}

穷举写法

当需要列举很多很多值的时候，而我们又只需要其中某几个值，那么我们可以使用"_"来表示

fn main() {
    let x = 0u8;
    let r = match x {
        1 => { 1 }
        2 => { 2 }
        3 => { 1 }
        _ => { 0 }
    };
}

if let

当控制流只有一种情况时，可以使用if let，可以用if let来简写match

fn main() {
    let x = 3;
    if let 3 = x {
        println!("匹配到了3")
    };
}