match

match用于对条件进行匹配以控制程序处理，对于enum十分有效或者是去用于Option

other和占位符_

在开始前，我们先来说以下other和占位符_，这常常在match的其余匹配中使用
比如：当周一的时候我要上课，周三的时候我要去钓鱼，而其他时间都得要上班，这时候使用other和占位符就很好，我只要处理周一和周三即可，其他都是相同的操作

区别

当我们不想使用通配模式获取的值时，请使用_，这是一个特殊的模式，可以匹配任意值而不绑定到该值

easy match

fn main() {
    let number = 46;
    match number {
        23=>println!("single"),
        46=>println!("double"),
        _=>()
    };

}

另一种

fn main() {
    let number = 45;
    match number {
        23=>println!("single"),
        46=>println!("double"),
       other=>()
    };

}

enum match

no value

没有任何值的时候我们可以直接去匹配enum的类型进行判断处理

enum Job {
    teacher,
    student,
    manager,
}

fn main() {
    let job = Job::teacher;
    match job {
        Job::teacher => println!("teach student"),
        Job::student => println!("listen class"),
        Job::manager => println!("drink coffee"),
    }
}

match inner

但是如果我们的enum中嵌套结构体或者元组，我们可以使用{}|()匹配取出名称进行处理

enum Job {
    teacher,
    student,
    manager {
        name: Option<String>
    },
}

fn main() {
    let job = Job::manager {
        name: Some("wangwu".to_string())
    };
    match job {
        Job::teacher => println!("teach student"),
        Job::student => println!("listen class"),
        Job::manager { name } => {
            println!("{}", name.unwrap());
        }
    }
}

Option match

我们可以对一个值是否为空进行匹配以进行处理

fn main() {
    let a = Some(5);
    let b = match a {
        Some(inner) => inner + 5,
        None => 10086
    };
    println!("{}", b);
}

more better way

更好的方式是：

fn main() {
    let a = Some(5);
    let b = match a {
        Some(inner) =>Ok( inner + 5),
        None =>Err("this is none")
    };
    println!("{}", b.unwrap());
}

这样把Option转为了Result进行处理

if-let整洁控制

实际上if-let就是if+let的结合模式，来处理只匹配一个模式的值而忽略其他模式的情况，若你只想处理一种情况，这比使用match更加好

fn main() {
    let a: Option<i32> = Some(100);
    if let Some(inner) = a {
        println!("{}", inner)
    }
}

包管理

以下是层级结构，我们需要记住

1. 包（Packages）：Cargo 的一个功能，它允许你构建、测试和分享 crate。
2. Crates ：一个模块的树形结构，它形成了库或二进制项目。
3. 模块（Modules）和 use：允许你控制作用域和路径的私有性。
4. 路径（path）：一个命名例如结构体、函数或模块等项的方式

Rust不止能在一个main.rs中编写代码当然也支持import|export模式，而且也支持模块模式（想象成SpringCloud类的项目）

虽然圣经上描述的很具体，但是我认为我们只需要快速了解并学会使用即可

模块(mod)拆分

Rust把文件名直接名为一个模块名，引入文件=引入想应模块
接下来我们快速看一下mod说明

声明mod

这里我们声明了lib的mod，里面包含controller mod和service mod

mod lib{
    fn run_lib(){
        println!("lib")
    }
    mod controller{
        fn run_controller(){
            println!("controller")
        }
    }
    mod service{
        fn run_service(){
            println!("service")
        }
    }
}

但是实际上，外部无法调用这些内部模块和方法

pub公开

通过使用pub关键字，我们可以对方法、常量、结构体、枚举、模块等进行公开

pub mod lib{
    pub fn run_lib(){
        println!("lib")
    }
    pub mod controller{
        fn run_controller(){
            println!("controller")
        }
    }
    pub mod service{
        fn run_service(){
            println!("service")
        }
    }
}

fn main() {
    lib::run_lib();
}

这样我们就能够访问到里面的模块和方法，但是依然无法访问到controller内部的和service内部的方法，因为没有被公开

use展开引用

通过使用use关键字，我们可以对内部可公开的引用直接使用，无需通过模块名称进行指定，这对于一些深模块是非常有用的

pub mod lib{
    pub fn run_lib(){
        println!("lib")
    }
    pub mod controller{
        pub fn run_controller(){
            println!("controller")
        }
    }
    pub mod service{
        pub fn run_service(){
            println!("service")
        }
    }
}

use lib::controller::run_controller;

fn main() {
    run_controller()
}

拆解模块

这里要说的真正的是拆解模块

pub mod lib{
    pub fn run_lib(){
        println!("lib")
    }
    pub mod controller{
        pub fn run_controller(){
            println!("controller")
        }
    }
    pub mod service{
        pub fn run_service(){
            println!("service")
        }
    }
}

现在我们有一个大模块，两个内部小模块
我们就应该在main.rs中创建一个lib.rs的文件存储lib模块中的内容
我们直接看结果或许会快很多

结构

main.rs

use ru2::lib::controller::run_controller;

fn main() {
    run_controller();
}

lib.rs

pub mod lib{
    pub mod controller;
    pub mod service;
}
pub fn run_lib(){
    println!("lib")
}

lib/service.rs

pub fn run_service(){
    println!("service")
}

lib/controller.rs

pub fn run_controller(){
    println!("controller")
}