【译】Rust模块系统的清晰解释

Posted on:2023-03-24 05:00
10 min read
    博客译文 Rust

看到一篇关于Rust模块系统的文章,文章内容言简意赅,通俗易懂,清晰解释了Rust的模块系统个。个人感觉非常不错,遂翻译到自己的博客,做此记录。

原文地址:Clear explanation of Rust’s module system ,作者 Shesh,如果觉得原文不错,可以关注他的Twitter

下面是正文部分。


Rust 的模块系统令人惊讶地令人困惑,并给初学者带来了很多挫败感。

在这篇文章中,我将使用实际示例来解释模块系统,以便您清楚地了解它的工作原理,并可以立即开始在您的项目中应用它。

由于 Rust 的模块系统非常独特,我要求读者以开放的心态阅读这篇文章,并避免将其与其他语言中的模块工作方式进行比较。

让我们使用此文件结构来模拟真实世界的项目:

my_project
├── Cargo.toml
└─┬ src
  ├── main.rs
  ├── config.rs
  ├─┬ routes
  │ ├── health_route.rs
  │ └── user_route.rs
  └─┬ models
    └── user_model.rs

这些是我们应该能够使用模块的不同方式:

这 3 个示例应该足以解释 Rust 的模块系统是如何工作的。

示例一

让我们从第一个示例开始 - 在 config.rs 中导入 main.rs

// main.rs
fn main() {
  println!("main");
}
// config.rs
fn print_config() {
  println!("config");
}

每个人都犯的第一个错误,只是因为我们有像 config.rs , health_route.rs 等文件,我们认为这些文件是 modules ,我们可以从其他文件导入它们。

下面是我们看到的(文件系统树)和编译器看到的(模块树):

令人惊讶的是,编译器只看到 crate 模块,即我们的 main.rs 文件。这是因为我们需要在 Rust 中显式构建模块树 - 文件系统树到模块树之间没有隐式映射。

我们需要在 Rust 中显式构建模块树,在Rust中没有隐式映射到文件系统。

要将文件添加到模块树中,我们需要使用 mod 关键字将该文件声明为子模块。接下来让人们感到困惑的是,你会假设我们将一个文件声明为同一文件中的模块。但是我们需要在不同的文件中声明这一点!由于模块树中只有 main.rs ,让我们在 main.rs 中将 config.rs声明为子模块。

mod 关键字声明了一个子模块,具有以下语法:

mod my_module;

在这里,编译器在同一目录中查找 my_module.rs 或 my_module/mod.rs

my_project
├── Cargo.toml
└─┬ src
  ├── main.rs
  └── my_module.rs

或者

my_project
├── Cargo.toml
└─┬ src
  ├── main.rs
  └─┬ my_module
    └── mod.rs

因为 main.rs 和 config.rs 在同一个目录中,让我们按如下方式声明配置模块,并使用 :: 语法访问 print_config 函数。

// main.rs
mod config;

fn main() {
  config::print_config();
  println!("main");
}
// config.rs
fn print_config() {
  println!("config");
}

模块树结构如下所示:

我们已经成功声明了 config 模块!但这还不足以在 config.rs 中调用 print_config 函数。默认情况下,Rust 中几乎所有内容都是私有的。

 pub 关键字使函数公开:

// main.rs
mod config;

fn main() {
  config::print_config();
  println!("main");
}
// config.rs
pub fn print_config() {
  println!("config");
}

现在我们已经成功地调用了在不同文件中定义的函数!

示例二

让我们尝试从 main.rs 调用 routes/health_route.rs 中定义的 print_health_route 函数。

// main.rs
mod config;

fn main() {
  config::print_config();
  println!("main");
}
// routes/health_route.rs
fn print_health_route() {
  println!("health_route");
}

正如我们之前讨论的,我们只能将 mod 关键字用于同一目录中的 my_module.rs 或 my_module/mod.rs 。

所以为了从 main.rs 调用 routes/health_route.rs 内部的函数,我们需要做以下事情:

  • 创建一个名为 routes/mod.rs 的文件,并在 main.rs 中声明 routes 子模块
  • 在 routes/mod.rs 中声明 health_route 子模块并使其公开
  • 公开 health_route.rs 中的函数
my_project
├── Cargo.toml
└─┬ src
  ├── main.rs
  ├── config.rs
  ├─┬ routes
+ │ ├── mod.rs
  │ ├── health_route.rs
  │ └── user_route.rs
  └─┬ models
    └── user_model.rs
// main.rs
mod config;
mod routes;

fn main() {
  routes::health_route::print_health_route();
  config::print_config();
  println!("main");
}
// routes/mod.rs
pub mod health_route;
// routes/health_route.rs
pub fn print_health_route() {
  println!("health_route");
}

模块树如下所示:

现在,我们可以调用文件夹中文件中定义的函数。

示例三

让我们尝试实现这样的调用关系 main.rs => routes/user_route.rs => models/user_model.rs 。

// main.rs
mod config;
mod routes;

fn main() {
  routes::health_route::print_health_route();
  config::print_config();
  println!("main");
}
// routes/user_route.rs
fn print_user_route() {
  println!("user_route");
}
// models/user_model.rs
fn print_user_model() {
  println!("user_model");
}

我们想从 main调用函数 print_user_route ,再调用print_user_model 。让我们进行与以前相同的更改 - 声明子模块,公开函数并添加 mod.rs 文件。

my_project
├── Cargo.toml
└─┬ src
  ├── main.rs
  ├── config.rs
  ├─┬ routes
  │ ├── mod.rs
  │ ├── health_route.rs
  │ └── user_route.rs
  └─┬ models
+   ├── mod.rs
    └── user_model.rs
// main.rs
mod config;
mod routes;
+ mod models;

fn main() {
  routes::health_route::print_health_route();
+ routes::user_route::print_user_route();
  config::print_config();
  println!("main");
}
// routes/mod.rs
pub mod health_route;
+ pub mod user_route;
// routes/user_route.rs
- fn print_user_route() {
+ pub fn print_user_route() {
  println!("user_route");
}
// models/mod.rs
+ pub mod user_model;
// models/user_model.rs
- fn print_user_model() {
+ pub fn print_user_model() {
  println!("user_model");
}

模块树如下所示:

等等,我们实际上还没有从 print_user_model 调用 print_user_route !到目前为止,我们只调用了 main.rs 中其他模块中定义的函数,我们如何从其他文件中做到这一点?

如果我们查看模块树, print_user_model 函数位于 crate::models::user_model 路径中。因此,为了在 不是 main.rs 的文件中使用模块 ,我们应该考虑在模块树中到达该模块所需的路径。

// routes/user_route.rs
pub fn print_user_route() {
+ crate::models::user_model::print_user_model();
  println!("user_route");
}

我们已经成功地从不是 main.rs 的文件中调用了文件中定义的函数。

super

如果我们的文件组织是多个目录深度,则完全限定的名称会变得太长。假设出于某种原因,我们想从 print_health_route 调用 print_user_route 。它们分别位于路径 crate::routes::health_route 和 crate::routes::user_route 下。

我们可以使用完全限定的名称 crate::routes::health_route::print_health_route() 来调用它,但我们也可以使用相对路径 super::health_route::print_health_route();  。请注意,我们已使用 super 来引用父范围。

模块路径中的 super 关键字是指父作用域。

pub fn print_user_route() {
  crate::routes::health_route::print_health_route();

  // 也可以使用super调用
  super::health_route::print_health_route();

  println!("user_route");
}

use

在上面的示例中使用完全限定的名称甚至相对名称会很乏味。为了缩短名称,我们可以使用 use  关键字将路径绑定到新名称或别名。

use 关键字用于缩短模块路径

pub fn print_user_route() {
  crate::models::user_model::print_user_model();
  println!("user_route");
}

上面的代码可以重构为:

use crate::models::user_model::print_user_model;

pub fn print_user_route() {
  print_user_model();
  println!("user_route");
}

除了使用名称 print_user_model ,我们还可以将其别名为其他名称:

use crate::models::user_model::print_user_model as log_user_model;

pub fn print_user_route() {
  log_user_model();
  println!("user_route");
}

外部模块

添加到 Cargo.toml 的依赖项全局可用于项目内的所有模块。我们不需要显式导入或声明任何内容来使用依赖项。

外部依赖项全局可用于项目内的所有模块。

例如,假设我们将rand添加到我们的项目中。我们可以直接在代码中使用它,如下所示:

pub fn print_health_route() {
  let random_number: u8 = rand::random();
  println!("{}", random_number);
  println!("health_route");
}

我们也可以使用 use 来缩短路径:

use rand::random;

pub fn print_health_route() {
  let random_number: u8 = random();
  println!("{}", random_number);
  println!("health_route");
}

总结

  • 模块系统是显式的 - 与文件系统没有 1:1 映射
  • 我们将一个文件声明为父级中的模块,而不是本身
  • mod 关键字用于声明子模块
  • 我们需要显式地将函数、结构等声明为公共函数,以便它们可以在其他模块中使用
  • pub 关键字使内容公开
  • use 关键字用于缩短模块路径
  • 我们不需要显式声明第三方模块
Toggle theme