在Rust中，模块有助于将程序分割成逻辑单元，以提高可读性和组织性。一旦程序变得更大，将其拆分为多个文件或命名空间非常重要。

模块有助于构建我们的程序。模块是项目的集合：包括函数、结构体甚至其他模块。

---

Module

定义模块

在Rust中，可以使用mod关键字来定义一个模块，语法如下：

mod module_name {
  // code
}

这里，module_name 是模块的名称。看下面的例子；

mod config {
    fn print() {
        println!("config!");
    }
}

上面的示例中，我们使用mod定义了以config为名称的一个模块。在模块内部，我们定义 了一个简单的函数print;

---

Rust 模块内项目的可见性

模块中的项目可以是私有的或公共的。默认情况下，模块是私有的。

这意味着模块内部的项目无法在模块外部访问。pub 关键字可用于使项目具有公共可见性。让我们看一个示例。

mod config {
    // items in modules by default have private visibility
    fn select() {
        println!("called config::select");
    }

    // use the `pub` keyword to override private visibility
    pub fn print() {
        println!("called config::print");
    }
}

在这里，我们定义一个名为config的模块，其中包含两个函数select()和print()。

print()函数以pub关键字开头，这意味着它具有公共可见性。但select()函数则没有。

如果你此时运行程序会发现有一些警告，这是因为我们并没有调用这些函数，现在，我们尝试调用一下；

mod config {
    // items in modules by default have private visibility
    fn select() {
        println!("called config::select");
    }

    // use the `pub` keyword to override private visibility
    pub fn print() {
        println!("called config::print");
    }
}

fn main() {
    // public items inside module can be accessed outside the parent module
    // call public print function from display module
    config::print();
}

在这里，我们使用config::print()语法来调用 config 模块内的公共函数 print()。:: 运算符用于分隔模块名称和要在模块内调用的项目。

但是，模块内部的私有项目不可在模块外部访问。如果我们尝试在 config 模块内调用私有函数 select()，将会收到编译错误。

---

注意：当在模块内部某个用pub修饰的方法调用模块内部非pub方法时，我们在调用该pub方法时，其涉及到的非pub方法也将具有pub性质；

我们看个例子：

mod player {
    // private function
    fn focus() {
        println!("called player::focus");
    }

    // public function
    pub fn shift() {
        println!("called player::shift");
    }

    // public function
    pub fn jump() {
        // call private function focus and shift inside the module
        focus();
        shift();
        println!("called player::jump");
    }
}

fn main() {
    // call public function jump from player module
    player::jump();
}

called player::focus
called player::shift
called player::jump

在这里，我们在player模块内定义了多个函数。请注意，我们能够在同一模块内的另一个函数jump()中调用私有函数focus()。

---

模块嵌套

一个模块中还可以在定义其他模块，这就是模块的嵌套；看例子：

// nested module
pub mod player {
    pub mod sprite {
        pub fn create() {
            println!("called player::sprite::create");
        }
    }
}

fn main() {
    // call public function create from sprite module which is inside player module 
    player::sprite::create();
}

输出：

called player::sprite::create

在这里，我们将一个 sprite 模块嵌套在 player 模块内部。我们在 sprite 模块内定义了一个名为 create() 的公共函数，在 main() 函数中通过 player::sprite::create() 调用。

---

use关键字

我们可以使用use关键字将模块内的项目引入当前作用域。use关键字帮助我们消除调用函数时写出完整模块路径的需要。让我们通过使用use关键字来重新编写我们的嵌套模块示例。

// nested module
pub mod player {
    pub mod sprite {
        pub fn create() {
            println!("called player::sprite::create");
        }
    }
}

// bring the create function into scope
use player::sprite::create;

fn main() {
    // call public function directly
    create();
}

这里，我们使用 use 关键字从 player 模块内部的 sprite 模块中将 create() 函数引入当前作用域。

这样我们可以直接调用 create() 函数，而不需要完全限定名称为 player::sprite::create()。

---

Crate和Package

一个 crate 可以包含一个或多个 Rust 模块，这些模块可以包含诸如函数、类型和常量之类的代码。

一个 crate 有两种类型：二进制 crate 和库 crate。二进制 crate 是一个 Rust 程序，编译成一个可执行文件或多个可执行文件，并且每个可执行文件都有一个 main() 函数。

库 crate 不会编译成可执行文件，也没有 main() 函数。库 crate 通常定义了可以在多个项目中使用的共享功能。Crates 可以捆绑在一起形成一个 package。

---

可以使用内置在Rust中的Cargo软件包管理器来创建软件包。 Cargo与Rust一起预安装。我们可以使用 cargo 来创建一个软件包。一个软件包包含一个或多个提供一组功能的crate。

一个包中可以包含许多二进制 crate，但最多只能包含一个库 crate。

---

创建二进制包

要创建一个二进制包，我们可以在终端中使用 cargo 命令。

$ cargo new hello_world --bin

我们使用 cargo 和--bin选项创建一个二进制包 hello_world。 这是 cargo 的默认行为。 让我们来看看 hello_world 包的内容。

hello_world
├── Cargo.toml
└── src
    └── main.rs

• hello_world 是包目录
• Cargo.toml 是一个包含有关 crate 的元数据的文件，如其名称、版本和依赖项
• src/main.rs 是 crate 根目录，包含二进制包的源代码

---

创建库包

$ cargo new hello_world_lib --lib

包结构如下：

hello_world_lib
├── Cargo.toml
└── src
    └── lib.rs

• hello_world_lib 是包目录
• Cargo.toml 是一个包含有关包的元数据的文件，例如其名称、版本和依赖关系
• src/lib.rs 是 crate 根目录，包含库包的源代码

一个包可以包含src/main.rs和src/lib.rs。在这种情况下，它有两个 crate：一个二进制 crate 和一个库 crate，两者都与包的名称相同。例如，

hello_world
├── Cargo.toml
└── src
    └── lib.rs
    └── main.rs

---

Cargo包管理器

Cargo

Cargo是Rust的包管理器。它与Rust一起预装，并可用于打包依赖项，管理它们以及构建和分发我们自己的包/库。

cargo的特点：

• 依赖管理

Cargo 可轻松管理我们项目的依赖项，包括添加、更新和删除依赖项。
构建和打包

Cargo 可自动构建和打包我们的 Rust 项目，创建可与他人共享的二进制或库代码。

• 文档生成

Cargo 可自动为我们的代码生成文档，使其他开发人员更容易理解和使用我们的库。

• 下载 crate

Cargo 可从 crates.io 下载并安装库，这是 Rust crate 的中央存储库。

• 运行二进制或测试

Cargo 可构建我们的源代码，运行可执行二进制文件，并运行我们的测试。

---

依赖管理

Cargo 的主要功能之一是可以下载、管理外部库。让我们看看如何从 crates.io 使用外部 crate 的示例。crates.io 是一个中央仓库，我们可以从中获取和发布用于 Rust 的共享库。

• 创建一个项目

$ cargo new hello_world

• 添加一个生成随机数的依赖rand,我们可以在cargo.toml中的[dependencies]部分进行添加

name = "hello_world"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
rand = "0.8.5"

我们还可以使用命令 cargo add rand 来为我们的项目添加依赖。

注意，如果通过命令的方式添加依赖，在添加时Rust就会加载编译该依赖，而通过cargo.toml手动添加时，程序会在你首次运行程序时进行加载编译的操作。

• 使用依赖

use rand::Rng;

fn main() {
    let mut rng = rand::thread_rng();

    // simulate rolling a die
    println!("roll = {}", rng.gen_range(1..=6));
}

# Output: roll = 5

---

构建和执行

Rust支持使用cargo命令对程序进行build和run.命令分别是

• cargo build
• cargo run

一般情况下，执行cargo run时，默认会自动执行cargo build,所以一般我们需要运行程序时不需要先执行build，再执行run,而是直接执行cargo run即可。

常用命令一览表：

Command	Description
cargo new	Create a new Rust project with basic directory structure
cargo build	Build (compile) the current project and generate a binary executable
cargo run	Build and run your current project (cargo build + run)
cargo check	Build the current project without generating a binary executable
cargo add	Add a new dependency and include it in Cargo.toml file
cargo update	Update all dependencies of current project to latest version