很多时候,我们写的代码需要按模块组织,因为我们无法将大量的代码都写在一个文件上,那样不容易维护,下面这篇文章主要给大家介绍了关于Rust模块使用方式的相关资料,需要的朋友可以参考下 

前言

本文适用于刚开始学习rust的同学，用于帮助理解rust模块间是如何相互引用的。本文尽量用极少的代码来演示，即便之前没有了解过rust也可以混个眼熟。用的时候可以有个印象。

如果你之前没有了解过rust，只需要知道：Cargo-依赖管理工具，类似于npm，Cargo 使用文件放置约定，即文件名就是模块名。crate-集装箱，是一组功能的封装，类似于npm包。

本文探讨的场景是在项目中对代码进行不同程度的文件拆分和模块抽离时，往往需要在一个文件中引入另一个模块的部分代码，在javascript中，我们可以通过导入导出来使用其他模块的代码，这个过程我们只需要关心导入路径是否正确。

export const name= xx
import lodash from './lodash'

而在rust中，模块不再通过文件路径的方式引入，而是通过cargo以及约定的模块声明方式来构建模块树，然后通过use关键字来使用。但是rust的文档在文件拆分和模块使用上做的示例不太详细，于是就参考一些发布的crate的组织方式进行了梳理。 

模块声明&使用

假如我们想实现一个加法模块，并提供给其他地方使用。我们可以有如下三种组织方式

Cargo 使用文件放置约定，因此模块查找以src目录下的rs文件或者目录为准，并且只会查找一级，嵌套文件夹下的rs文件不可以直接被其他文件使用。

方法一：直接在根文件下声明 add.rs

我们可以通过在src下添加模块名同名的文件，cargo就可以识别到add模块。

├── Cargo.lock
├── Cargo.toml
├── src
│   ├── add.rs
│   ├── lib.rs

方法二：声明add文件夹，文件夹下包含 mod.rs 

如果模块是文件夹，则必须有mod.rs文件。这类似于javascript的index.js。cargo仍然可以识别到这是add模块

├── Cargo.lock
├── Cargo.toml
├── src
│   ├── add
│   │   ├── mod.rs
│   ├── lib.rs

假设我们的代码内容如下,并位于文件add.rs 或者add/mod.rs内 

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

那么在lib.rs中我们可以通过如下方式调用我们的add模块 

// 声明模块并引用模块内的函数
mod add;
pub use crate::add::add_fn;
pub fn test_lib() {
  add_fn(1,2);
}

方法三：add.rs和add文件夹同时存在 

这种方式的目录结构看起来像下面这样

├── Cargo.lock
├── Cargo.toml
├── src
│   ├── add
│   │   └── add_m.rs
│   ├── add.rs // index.js
│   ├── lib.rs

add.rs负责入口模块的导入导出，add文件夹下则存放其余相关联的其他模块。这类似于javascript的index.js统一导出了多个其他模块。和上面不同的是这里 导入使用到了mod关键字来拆分模块； 

文件内容看起来像下面这样

add.rs

pub mod add_m;
// 类似于 export * from './validate; export * from './helper'

add/add_m.rs 

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

lib.rs 

mod add;
pub use crate::add::add_m::add_fn;
pub fn test_lib() {
  add_fn(1,2);
}

上述三种方式使用较多的应该是前两种，并且在大型项目内第二种更为合理，可以更好的组织文件。那么当一个模块文件夹下拆分多个模块文件时该怎调用相邻文件呢？ 

同模块相邻文件引用

我们调整目录结构如下

├── Cargo.lock
├── Cargo.toml
├── src
│   ├── add
│   │   ├── mod.rs
│   │   ├── print.rs
│   │   └── user.rs // user会调用print的方法
│   ├── lib.rs

在add模块下多了print和user。user会调用print的方法。 

print.rs

pub mod my_print {
    pub fn print_hello() {
        println!( hello )
    }
}
// 这里的pub mod 可以简单理解为ts的declare module ，里面是module的可用属性
// declare module my_print {
//  export function print_hello(): string;
// }

user.rs 

use super::print::my_print;
pub fn hello_user() {
    my_print::print_hello();
}
pub struct User {
    pub name: String,
}

同模块下的文件互相引用使用super关键字。 

mod.rs

// mod.rs为入口文件， 下面用mod声明会先去同文件夹下查找同名文件，如果没有则看是否有满足条件   的同名文件夹
// 例如 add 文件夹下没有print.rs 则查找是否有print文件夹并且文件夹下有mod.rs。
mod print;
mod user;

// 因为是同一个模块文件夹下，并且在入口文件使用，所以这里应self
pub use self::user::hello_user;
pub use self::user::User;

pub mod add_fn {
    // use super::*; 如果有这行，则下面不用每次调用super
    pub fn add(a: i32, b: i32) -> i32 {
      // 注意这里super关键字，因为hello_user是在另一个模块声明的，模块间不能直接调用所以需要使用super来从模块根进行查找调用
        super::hello_user();
        let value = super::User {
            name: String::from( Rust ),
        };

        println!( user name {} , value.name);
        a + b
    }
}

pub fn test_out_ref() {
  // 这里不在需要super因为不在mod内定义
    hello_user();
}

不同模块引用

我们新增一个模块multip,返回两个数相乘的结果，目录结构如下

├── Cargo.lock
├── Cargo.toml
├── src
│   ├── add
│   │   ├── mod.rs
│   │   ├── print.rs
│   │   └── user.rs // user会调用print的方法
│   ├── multip  // ------- 新增这个模块
│   │   ├── mod.rs法
│   ├── lib.rs

multip/mod.rs 

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

假设add文件引入multip 

mod print;
mod user;

pub use self::user::hello_user;
pub use self::user::User;
// 新增下面这行
use crate::multi::multip;

如此便可以使用另一个模块的内容了。当然其他模块的相互引用方式一致。 

小结

rust的模块使用方式总体来说是比较简单的，由于官方文档在模块拆分和组织上并没有进行较完善的说明，所以对于刚从js转到rust学习的同学可能会有一点不适应。通过前面内容已经较为清晰的梳理了下使用方式。希望可以对需要的同学有所帮助。