前言

  为了方便大家学习掌握Rust 语言的语法和概念，因此我将带来一篇Rust 组织管理的内容。任何一门编程语言如果不能组织代码都是难以深入的，几乎没有一个软件产品是由一个源文件编译而成的。对于一个工程来讲，组织代码是十分重要的，Rust 中有三个重要的组织概念：包、箱、模块。

1、Rust 的代码组织

1. Package（包）：Cargo 的特性，用来构建、测试、共享crate
2. Crate（箱）：一个模块树，它可以产生一个library或可执行文件
3. Moudle（模块）：配合use关键字，用来控制代码的组织、作用域、私有路径等

1.1、包（Package）

当我们使用 Cargo 执行 new 命令创建 Rust 工程时，工程目录下会建立一个 Cargo.toml 文件。

• 工程的实质就是一个包，包必须由一个 Cargo.toml 文件来管理，该文件描述了包的基本信息以及依赖项。

• 一个包最多包含一个库"箱"（library crate），可以包含任意数量的二进制"箱"（binary crate），但是至少包含一个"箱"（不管是库还是二进制"箱"）。

• 当使用 cargo new 命令创建完包之后，src 目录下会生成一个 main.rs 源文件，Cargo 默认这个文件为二进制箱的根，编译之后的二进制箱将与包名相同。

1.2、箱（Crate）

• "箱"是二进制程序文件或者库文件，存在于包中。

• "箱"是树状结构的，它的树根是编译器开始运行时编译的源文件所编译的程序。

注意：“二进制程序文件"不一定是"二进制可执行文件”，只能确定是是包含目标机器语言的文件，文件格式随编译环境的不同而不同。

1.3、模块（Moudle）

1.3.1、moudle的定义

对于一个软件工程来说，我们往往按照所使用的编程语言的组织规范来进行组织，组织模块的主要结构往往是树。

• Java 组织功能模块的主要单位是类，而 JavaScript 组织模块的主要方式是 function。

• 这些先进的语言的组织单位可以层层包含，就像文件系统的目录结构一样。

• Rust 中的组织单位是模块（Module）。

1.3.2、建立moudle

• 使用mod关键字
• 可多层嵌套
• 可包含其他项（struct、enum、常量、trait、函数等）的定义

示例：

src/main.rs和 src/lib.rs叫做crate roots：

• 这里便是一个简单的模块嵌套，子模块中我定义了若干空实现的函数
• 这两个文件（任意一个）的内容形成了名为crate 的模块，位于整个模块树的根部

2、路径表示

• 为了在Rust 的模块中找到某个条目，需要使用路径
• 路径的两种形式：
  • 绝对路径：从crate root 开始，使用crate 名，或者字面值 crate
    • crate 是根模块，是绝对路径的起始位置
  • 相对路径： 从当前模块开始，使用super或者当前模块的标识符
    • super：用来访问父级或者同级模块路径中的内容
• 路径至少由一个标识符组成，标识符之间使用::

示例：

mod front_of_house{
    pub mod hosting{
        pub fn add_waitlist(){print!("调用add_waitlist")}
    }
}
pub fn eat_at_restaurant(){
    crate::front_of_house::hosting::add_waitlist();

    front_of_house::hosting::add_waitlist();
}

3、访问权限

Rust 中有两种简单的访问权：公共（public）和私有（private）。

• 默认情况下，如果不加修饰符，模块中的成员访问权将是私有的。

• 如果想使用公共权限，需要使用 pub 关键字。

• 对于私有的模块，只有在与其平级的位置或下级的位置才能访问，不能从其外部访问。

3.1、super 实例

mod nation {
    pub mod government {
        pub fn govern() {}
    }

    mod congress {
        pub fn legislate() {}
    }
   
    mod court {
        fn judicial() {
            super::congress::legislate();
        }
    }
}

fn main() {
    nation::government::govern();
}

3.2、struct 实例

如果模块中定义了结构体，结构体除了其本身是私有的以外，其字段也默认是私有的。所以如果想使用模块中的结构体以及其字段，需要 pub 声明：

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}
pub fn eat_at_restaurant() {
    let mut meal = back_of_house::Breakfast::summer("Rye");
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);
}
fn main() {
    eat_at_restaurant()
}
//运行结果：I'd like Wheat toast please

3.3、enum 实例

枚举类变体可以内含字段，但不具备类似的性质：

mod SomeModule {
    pub enum Person {
        King {
            name: String
        },
        Quene
    }
}

fn main() {
    let person = SomeModule::Person::King{
        name: String::from("Blue")
    };
    match person {
        SomeModule::Person::King {name} => {
            println!("{}", name);
        }
        _ => {}
    }
}
//运行结果：Blue

有关Rust 代码的组织管理就分享到这里了，下篇博客将详细介绍use关键字的使用，敬请期待！