在 Rust 中，模块是一种将代码组织和封装的机制，它有助于将大型程序分解为更小、更易于管理的小模块。模块允许你将相关的函数、结构体、枚举、常量等元素组合在一起，并且可以控制这些元素的可见性，以实现信息隐藏和封装，提高代码的可维护性和可复用性。

下文的【元素】指的是函数、结构体、枚举、常量。

模块的基本语法

在 Rust 中，模块的基本语法如下：

mod module_name {
  // 模块的内容
}

内联模块

直接在源文件中使用 mod 关键字创建内联模块。通过 :: 操作符，你可以访问模块中的元素。例如：

mod website {
  pub fn getTitle() {
    println!("Kelen.cc");
  }
}
fn main() {
  website::getTitle(); // 调用 site 模块中的 getTitle 函数
}

外部文件模块

如果模块的功能代码比较复杂需要拆分或者想要区分模块的功能，你可以将模块的功能代码放在单独的文件中。

假设有一个名为 website.rs 的模块，暴露了一个名为 getTitle 的函数：

pub fn getTitle() {
  println!("Kelen.cc");
}

然后在 main.rs 中使用 mod 关键字引入模块：

mod website;
fn main() {
  website::getTitle(); // 调用 site 模块中的 getTitle 函数
}

在这个例子中，mod website; 引入了 website 模块，然后你可以在 main 函数中使用 website::getTitle() 来调用 getTitle 函数了。

模块层次结构

想像一下，一个图书馆的书架上有很多分类，每个分类下又有很多书，每本书都有自己是书名。在 Rust 中，模块的层次结构就像这样：

mod library {
  mod science {
    pub fn physics() {
      println!("物理");
    }
    pub fn chemistry() {
      println!("化学");
    }
  }
  mod arts {
    pub fn drawing() {
      println!("绘画");
    }
    pub fn singing() {
      println!("歌唱");
    }
  }
}

在这个例子中，library 是一个模块，它包含两个子模块 science 和 arts。每个子模块又包含了一些函数，比如 science 模块中有 physics 和 chemistry 函数，arts 模块中有 drawing 和 singing 函数。

要调用这些函数，你可以使用模块的完整路径：

fn main() {
  library::science::physics();
  library::arts::drawing();
}

使用 self 关键字

当你需要在模块内部访问自己的元素时，可以使用 self 关键字。self 关键字表示当前模块或结构体的范围。

mod library {
  pub fn science() {
    println!("科学");
  }
  pub fn arts() {
    println!("艺术");
  }
  pub fn selfFunction() {
    self::science();
    self::arts();
  }
}
fn main() {
  library::selfFunction();
}

使用 super 关键字

当你需要在子模块中访问父模块的元素时，可以使用 super 关键字。

mod library {
  pub fn get_library_name () {
    println!("Kelen.cc");
  }
  pub mod arts {
    pub fn get_library_name () {
      super::get_library_name();
    }
  }
}
fn main() {
  library::arts::get_library_name();
}

使用 use 关键字

当你需要经常使用某个模块或模块中的元素时，反复使用模块的完整路径会变得可读性差。这时可以使用 use 关键字来引入模块或元素，使代码更简洁。还是是上面的例子：

use library::science;
fn main() {
  science::physics();
  science::chemistry();
}

在这个例子中，use library::science; 引入了 science 模块，使得你可以直接使用 physics 和 chemistry 函数，而不需要使用完整的路径。

我们也可以使用 as 关键字来重命名模块或元素：

use library::science as sci;
fn main() {
  sci::physics();
  sci::chemistry();
}

可见性和封装

默认情况下，模块内的元素是私有的，细心的朋友可能发现我们在定义函数前面加了 pub 关键字，这是因为默认情况下，模块内的元素是私有的，只能在模块内部访问。只有使用 pub 关键字才能将其变为公共的，使其可以被外部模块访问。这个特性可以方便我们控制哪些元素是公开的，哪些是私有的。

mod library {
  pub fn science() {
    println!("科学");
  }
  fn arts() {
    println!("艺术");
  }
}
fn main() {
  library::science();
  library::arts(); // 报错：无法调用，因为 arts 函数是私有的
}

路径

在 Rust 中，有绝对路径和相对路径。绝对路径从 crate 的根开始，以 crate 关键字开始，而相对路径是相对于当前模块的。例如：

mod my_mod {
  pub mod inner_mod {
    pub fn inner_function() {
      println!("This is an inner function");
    }
  }
}
fn main() {
  // 使用绝对路径
  crate::my_mod::inner_mod::inner_function();
  // 使用相对路径
  my_mod::inner_mod::inner_function();
}

在 main 函数中，使用绝对路径 crate::my_mod::inner_mod::inner_function() 可以调用 inner_function，同时也可以使用相对路径 my_mod::inner_mod::inner_function() 来调用，因为 main 函数和 my_mod 在同一层次结构中。

总结

模块允许你将代码分解为更小的部分，提高代码的可维护性和可复用性。通过 mod 关键字创建模块，使用 pub 关键字控制元素的可见性，使用 use 关键字简化代码的引用，以及利用路径在模块层次结构中导航，可以写出结构清晰、易于理解和维护的 Rust 代码。合理利用模块可以帮助你管理代码库的复杂性，隐藏内部实现细节，只暴露必要的接口给外部使用，保证代码的安全性和可靠性。

在实际应用中，根据程序的规模和复杂度，灵活运用模块系统，可以更好地构建出高质量的 Rust 程序。同时，模块系统与 Rust 的其他特性（如所有权、生命周期等）相结合，可以让你在开发过程中避免很多潜在的问题，确保程序的正确性和性能。