Rust 中的模块

· 806 words · 5 min

在 Rust 中，mod 是用来定义模块的关键字。模块（mod）是 Rust 中的一种代码组织方式，用于将代码按逻辑分组，帮助开发者管理大型项目、封装代码、控制可见性（public/private），以及减少命名冲突。

模块的基本定义

通过 mod 关键字，可以定义一个模块。模块可以包含函数、结构体、枚举、常量、类型定义等。模块的内容可以是私有的，也可以是公开的。

mod my_module {
    pub fn say_hello() {
        println!("Hello from my_module!");
    }
}

fn main() {
    my_module::say_hello();
}

mod my_module 定义了一个名为 my_module 的模块。pub fn say_hello 将函数设为公共（pub），以便模块外的代码可以调用它。

模块的可见性

在 Rust 中，默认情况下，模块内的所有项（如函数、结构体、常量）都是私有的。如果你希望某个函数、类型等可以在模块外部访问，你需要使用 pub 关键字将其公开。

mod my_module {
    pub fn public_function() {
        println!("This is a public function!");
    }

    fn private_function() {
        println!("This is a private function.");
    }
}

fn main() {
    my_module::public_function(); // 可以访问
    // my_module::private_function(); // 无法访问，会编译报错
}

嵌套模块

模块可以包含其他模块，形成嵌套结构。这允许你对代码进行更细粒度的组织。

mod outer_module {
    pub fn outer_function() {
        println!("This is in the outer module.");
    }

    mod inner_module {
        pub fn inner_function() {
            println!("This is in the inner module.");
        }
    }
}

fn main() {
    outer_module::outer_function(); // 访问外部模块的函数
    outer_module::inner_module::inner_function(); // 访问嵌套模块的函数
}

文件系统中的模块组织

Rust 模块不仅可以定义在同一个文件中，也可以通过文件夹和文件来组织模块。通常 Rust 项目遵循以下约定：

文件结构示例：

src/
  main.rs
  my_module.rs
  utils/
    mod.rs
    helper.rs

在 main.rs 中：

mod my_module; // 引入 my_module.rs
mod utils;     // 引入 utils/mod.rs

fn main() {
    my_module::say_hello();
    utils::helper::assist();
}

在 utils/mod.rs 中：

pub mod helper; // 引入 helper.rs

fn util_function() {
    println!("This is a function inside the utils module.");
}

super 和 self 关键字

在模块内部，你可以使用 super 访问父模块，使用 self 引用当前模块。

mod parent {
    pub mod child {
        pub fn child_function() {
            println!("Child function");
        }

        pub fn call_parent_function() {
            super::parent_function(); // 调用父模块的函数
        }
    }

    pub fn parent_function() {
        println!("Parent function");
    }
}

fn main() {
    parent::child::call_parent_function();
}

use 关键字与模块引入

为了简化模块的使用，Rust 提供了 use 关键字来引入模块或其项，使调用更加简洁。

mod my_module {
    pub fn function_one() {
        println!("Function one");
    }

    pub fn function_two() {
        println!("Function two");
    }
}

fn main() {
    use my_module::function_one;
    
    function_one(); // 不再需要 my_module::function_one
    // my_module::function_two(); // 仍需全路径，因为只引入了 function_one
}

总结

Rust