大家好，
今天是学习 Rust 的第 11 天，今天我们来看看 Rust 的模块系统。我们可以利用这个系统来管理不断增长的项目，并跟踪各个模块的存储位置。
介绍
在 Rust 中，模块系统通过将相关函数、类型和其他项目分组来帮助保持代码组织良好，从而更容易管理和重用项目中的代码。
例如：
假设你的一部分代码是用于管理数据库，你并不希望它被图像渲染器访问。所以我们将它们存储在不同的位置，不同的 modules 中。
我们可以使用 use 关键字来访问不同 modules 的特定部分。
当我们运行 cargo new 命令时，我们实际上正在创建一个包，而包存储着 crates。有两种类型的 crates：
- 二进制 crate：可以直接执行
- 库 crate：可以被其他程序/包使用
每个 crate 都存储着模块，这些模块组织了代码并控制了 Rust 程序的私密性。
让我们深入了解一下。
通过运行以下命令创建一个新的包：
$ cargo new module_system
$ cd module_system
$ ls
Cargo.toml
src/
查看 Cargo.toml 文件，我们可以看到：
[package]
name = "module_system"
version = "0.1.0"
edition = "2021" [dependencies]
根据 Rust 的约定，我们在这个文件中看不到任何 crates，但是我们确实有一个 main.rs 文件。这意味着在我们的包中默认有一个名为 module_system 的二进制 crate。
如果在我们的 src 目录中有 lib.rs 文件，库 crate 也会遵循同样的约定，它将自动创建一个名为 module_system 的库 crate。
包和 crate 的规则
- 一个包至少必须有一个 crate。
- 一个包可以包含 0 个库 crate 或 1 个库 crate。
- 一个包可以有
n个二进制 crates。
模块
模块是使用 mod 关键字定义的库 crate。它们用于更好地结构化 Rust 应用程序，让我们通过一个示例更好地理解它。
要创建一个库 crate，我们可以使用以下命令
cargo new --lib user
rust">//文件：src/lib.rs mod user{ mod authentication{ fn create_account(){} fn login(){} fn forgot_password(){} } mod edit_profile{ fn change_username(){} fn chang_pfp(){} fn change_email(){} }
}
这就是一个模块会是什么样子。
一个模块可以包含多个子模块，在一个模块内部我们可以定义结构体、枚举、函数等。
这种方法在管理和维护代码库方面非常有用。未来，如果我们需要更改 forgot_password 函数的某个特定部分，我们将准确地知道在哪里找到它…
调用模块中的函数
假设我想要在我的服务中注册一个新用户，并且需要使用 create_account 函数。我该如何调用它呢？
rust">//文件：src/lib.rs mod user{ pub mod authentication{ pub fn create_account(){} fn login(){} fn forgot_password(){} } mod edit_profile{ fn change_username(){} fn chang_pfp(){} fn change_email(){} }
} pub fn call_module_function(){ //绝对路径 crate::user::authentication::create_account(); //相对路径 user::authentication::create_account();
}
我们为我们的 authentication 模块和 create_account 函数添加了 pub 关键字，因为默认情况下它是 private 的，不能被调用，因为模块私密性规则的存在
相对路径 指的是在同一模块层次结构中访问模块或项而不指定根路径，而 绝对路径 指的是通过指定根模块或 crate 来访问它们。
作为参考，这里是模块层次结构的示意图…
super 关键字也可以用于相对调用函数，super 允许我们引用父模块…
示例
rust">mod parent_module { pub fn parent_function() { println!("This is a function in the parent module."); }
} mod child_module { // 使用 `super` 从父模块导入 `parent_function` use super::parent_module; pub fn child_function() { println!("This is a function in the child module."); // 使用 `super` 调用父函数 parent_module::parent_function(); }
} fn main() { // 调用子函数，进而调用父函数 child_module::child_function();
}
模块私密性规则
模块具有控制哪些项（如结构体、函数和变量）可见或可访问的私密性规则。
这些规则有助于实施封装，并防止意外访问模块内部细节。
rust">mod my_module { // 公有结构体 pub struct PublicStruct { pub public_field: u32, } // 私有结构体 struct PrivateStruct { private_field: u32,} // 创建 `PrivateStruct` 实例的公有函数 pub fn create_private_struct() -> PrivateStruct { PrivateStruct { private_field: 42 } }
} fn main() { // 从外部模块创建 PublicStruct 实例是允许的 let public_instance = my_module::PublicStruct { public_field: 10 }; println!("Public field of PublicStruct: {}", public_instance.public_field); // 从外部模块创建 PrivateStruct 实例是不允许的 // let private_instance = my_module::PrivateStruct { private_field: 20 }; // 这将导致编译时错误 // 不允许访问 PublicStruct 的私有字段 // println!("Private field of PublicStruct: {}", public_instance.private_field); // 这将导致编译时错误 // 但是，我们可以使用提供的公有函数创建和访问 PrivateStruct 的实例 let private_instance = my_module::create_private_struct(); // println!("Private field of PrivateStruct: {}", private_instance.private_field); // 这将导致编译时错误
}
- Rust 的模块系统允许将代码组织成逻辑单元。
- Rust 模块中的可见性和访问控制通过私密性规则实施。
- 在 Rust 中，项（如结构体、函数和变量）可以在模块内部标记为公有或私有。
- 公有项可以从模块外部访问，而私有项则不行。
- 公有项通常使用
pub关键字标记，而私有项则没有显式标记。 - 私有项只能在定义它们的模块内部访问，促进封装并隐藏实现细节。
pub关键字用于使项在模块外部可见，允许它们被代码库的其他部分使用。- Rust 中的
super关键字允许访问父模块中的项，便于在 crate 中进行分层组织和访问控制。
Use 关键字
use 关键字允许将路径引入作用域，这样你就不必一遍又一遍地指定路径了，让我们来看看我们之前的例子。
rust">
//文件：src/lib.rs mod user{ pub mod authentication{ pub fn create_account(){} fn login(){} fn forgot_password(){} } mod edit_profile{ fn change_username(){} fn chang_pfp(){} fn change_email(){} }
} //将模块添加到我们的作用域中
use crate::user::authentication; pub fn call_module_function(){ //我们可以直接调用它们，而不是这样 //crate::user::authentication::create_account(); //user::authentication::create_account(); authentication::create_account();
}
嵌套路径
rust">mod outer_module { pub mod inner_module { pub fn inner_function() { println!("This is an inner function."); } pub struct InnerStruct { pub value: i32, } }
} use outer_module::inner_module::inner_function;
use outer_module::inner_moduel::InnerStruct; fn main() { // 调用内部函数 inner_function(); // 创建 InnerStruct 的实例 let inner_struct_instance = InnerStruct { value: 42 }; println!("Value of inner struct: {}", inner_struct_instance.value);
}
注意两个 use 语句都以 outer_module::inner_module:: 开头
我们可以通过以下方式嵌套两个 use 语句：
use outer_module::inner_module::{inner_function, InnerStruct};
分离文件中的模块
为了更好地跟踪我们的项目并更好地组织它，我们可以将不同的模块存储在不同的文件中。让我们将 authentication 模块做到这一点。
rust">
mod user{ pub mod authentication{ pub fn create_account(){} fn login(){} fn forgot_password(){} } mod edit_profile{ fn change_username(){} fn chang_pfp(){} fn change_email(){} }
}
步骤 1：在 src/ 目录中创建与模块名相同的文件，在我们的情况下是 authentication.rs
步骤 2：将所有函数复制到该文件中，但保留模块声明
rust">
//文件：src/authentication.rs
pub fn create_account(){}
fn login(){}
fn forgot_password(){}//文件：src/lib.rs
mod user{ pub mod authentication; //将花括号改为分号 mod edit_profile{ fn change_username(){} fn chang_pfp(){} fn change_email(){} }
}
这样做的效果是，编译器会查找与模块名相同的文件，并将所有函数和其他数据放入该模块。
我们也可以对父模块做同样的操作…
结论
总之，Rust 的模块系统是一个有效的工具，用于将代码组织成逻辑片段，从而实现代码的维护和重用。模块支持分层组织、私密性管理和代码封装。Rust 通过诸如 use 关键字、嵌套路径和将模块划分为独立文件等功能，为开发人员提供了多功能且可扩展的方法来管理项目复杂性。
