Rust 模块系统高级应用指南

最新推荐文章于 2026-06-30 08:22:09 发布

原创最新推荐文章于 2026-06-30 08:22:09 发布 · 44 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

Rust 模块系统高级应用指南

1. 模块系统基础

Rust 的模块系统用于组织代码，它允许我们将代码分解为多个文件和模块，提高代码的可读性和可维护性。

// src/lib.rs
mod utils;

pub fn main() {
    utils::greet();
}

// src/utils.rs
pub fn greet() {
    println!("Hello from utils module");
}

2. 模块层次结构

2.1 嵌套模块

// src/lib.rs
mod utils {
    pub mod math {
        pub fn add(a: i32, b: i32) -> i32 {
            a + b
        }
        
        pub fn subtract(a: i32, b: i32) -> i32 {
            a - b
        }
    }
    
    pub mod string {
        pub fn capitalize(s: &str) -> String {
            let mut chars = s.chars();
            match chars.next() {
                None => String::new(),
                Some(first) => first.to_uppercase().to_string() + chars.as_str(),
            }
        }
    }
}

pub fn main() {
    let sum = utils::math::add(1, 2);
    println!("Sum: {}", sum);
    
    let capitalized = utils::string::capitalize("hello");
    println!("Capitalized: {}", capitalized);
}

2.2 文件模块

src/
├── lib.rs
└── utils/
    ├── mod.rs
    ├── math.rs
    └── string.rs

// src/lib.rs
mod utils;

pub fn main() {
    let sum = utils::math::add(1, 2);
    println!("Sum: {}", sum);
    
    let capitalized = utils::string::capitalize("hello");
    println!("Capitalized: {}", capitalized);
}

// src/utils/mod.rs
pub mod math;
pub mod string;

// src/utils/math.rs
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}

// src/utils/string.rs
pub fn capitalize(s: &str) -> String {
    let mut chars = s.chars();
    match chars.next() {
        None => String::new(),
        Some(first) => first.to_uppercase().to_string() + chars.as_str(),
    }
}

3. 可见性控制

3.1 `pub` 关键字

pub 关键字用于控制模块、函数、结构体和枚举的可见性。

// 公开模块
pub mod utils {
    // 公开函数
    pub fn public_function() {
        println!("Public function");
        private_function();
    }
    
    // 私有函数
    fn private_function() {
        println!("Private function");
    }
    
    // 公开结构体
    pub struct PublicStruct {
        // 公开字段
        pub public_field: i32,
        // 私有字段
        private_field: i32,
    }
    
    impl PublicStruct {
        // 公开方法
        pub fn new() -> Self {
            Self {
                public_field: 0,
                private_field: 0,
            }
        }
        
        // 私有方法
        fn private_method(&self) {
            println!("Private method");
        }
    }
}

3.2 `pub(crate)` 可见性

pub(crate) 表示在整个 crate 中可见，但在 crate 外部不可见。

pub(crate) mod internal {
    pub fn internal_function() {
        println!("Internal function");
    }
}

pub fn main() {
    internal::internal_function();
}

3.3 `pub(super)` 可见性

pub(super) 表示在父模块中可见。

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

pub fn main() {
    parent::parent_function();
    // parent::child::child_function(); // 错误：不可见
}

4. 高级模块技巧

4.1 使用 `use` 语句

use 语句可以简化模块路径的使用。

use utils::math::{add, subtract};
use utils::string::capitalize;

pub fn main() {
    let sum = add(1, 2);
    println!("Sum: {}", sum);
    
    let difference = subtract(5, 3);
    println!("Difference: {}", difference);
    
    let capitalized = capitalize("hello");
    println!("Capitalized: {}", capitalized);
}

4.2 使用 `as` 关键字

as 关键字可以为导入的项指定别名。

use utils::math::add as addition;
use utils::string::capitalize as cap;

pub fn main() {
    let sum = addition(1, 2);
    println!("Sum: {}", sum);
    
    let capitalized = cap("hello");
    println!("Capitalized: {}", capitalized);
}

4.3 使用 `*` 通配符

* 通配符可以导入模块中的所有项。

use utils::math::*;

pub fn main() {
    let sum = add(1, 2);
    println!("Sum: {}", sum);
    
    let difference = subtract(5, 3);
    println!("Difference: {}", difference);
}

5. 实际应用场景

5.1 大型项目结构

对于大型项目，我们可以使用多级模块结构来组织代码。

src/
├── lib.rs
├── models/
│   ├── mod.rs
│   ├── user.rs
│   └── post.rs
├── controllers/
│   ├── mod.rs
│   ├── user_controller.rs
│   └── post_controller.rs
└── utils/
    ├── mod.rs
    ├── validation.rs
    └── error.rs

5.2 测试模块

Rust 支持在模块中添加测试代码。

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_add() {
        assert_eq!(add(1, 2), 3);
        assert_eq!(add(-1, 1), 0);
    }
}

5.3 条件编译

使用 #[cfg] 属性可以根据条件编译代码。

#[cfg(feature = "logging")]
pub mod logging {
    pub fn log(message: &str) {
        println!("[LOG] {}", message);
    }
}

#[cfg(not(feature = "logging"))]
pub mod logging {
    pub fn log(_message: &str) {
        // 空实现
    }
}