开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第13天，点击查看活动详情

类似es6的模块化，Rust通过package、create、module来实现代码的模块化管理

Rust如何进行模块化开发？

Rust的代码组织包括：哪些细节可以暴露，哪些细节是私有的，作用域内哪些名称有效等等。

而这些功能被统称为模块系统，模块系统被分为（由上到下层层包含）：

• Package（包）：Cargo的特性，让你构建、测试、共享create
• Create（单元包）：一个模块树，它可以产生一个library或可执行文件
• Module（模块）、use：让你控制代码的组织、作用域、私有路径
• Path（路径）：为struct、function或module等项命名的方式

Package和Create

create的类型：

• binary（二进制create）
• library（库create）

其中，关于Create，还有个概念——Create Root：

• 是源代码文件
• Rust编译器从这里开始，组成你的Create的根Module

一个Package：

• 包含一个Cargo.toml，它描述了如何构建这些Crates
• 只能包含0-1个library create（库create）
• 可以包含任意数量的binary create（二进制create）
• 但必须至少包含一个create（library或binary）

我们使用cargo新建一个项目

然后会提示： Created binary (application) my-project package，这代表我们创建了一个二进制的应用程序，名叫my-project的package

我们进入这个文件夹：

我们可以看到src/min.rs文件，这是我们程序的入口文件，但是我们在Cargo.toml中并没有看到相关的配置：

[package]
name = "my-project"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

这是因为cargo有一些惯例

Cargo的惯例

• src/main.rs是binary create的create root

• create的名与package名相同

如果我们还有一个这个文件：src/lib.rs，那么：

• 表明package包含一个library create
• 它是library create的create root
• create的名与package名相同

Cargo将会把create root文件交给rustc（rust编译器）来构建library或者binary

一个Package可以同时包含src/main.rs和src/lib.rs

一个Package也可以有多个binary create：

• 文件放在src/bin，放在这里的每个文件都是单独的binary create

Create的作用

将相关功能组合到一个作用域内，便于在项目间进行共享。

同时，这也能防止命名冲突，例如rand create，访问它的功能需要通过它的名字：rand

定义module来控制作用域和私有性

Module：

• 在一个create内，将代码进行分组
• 增加可读性，易于复用
• 控制项目（item）的私有性。public，private

建立module：

• mod关键字
• 可嵌套
• 可包含其他项（struct、enum、常量、trait、函数等）的定义

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}
        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}
        fn serve_order() {}
        fn take_payment() {}
    }
}

src/main.rs 和 src/lib.rs 叫做create roots：

• 这两个文件（任意一个）的内容形成了名为create的模块，位于整个模块树的根部
• 整个模块树在隐式的模块下

路径Path

路径的作用是为了在rust的模块中找到某个条目

路径的两种形式：

• 绝对路径：从create root开始，使用create名或字面值create
• 相对路径：从当前模块开始，使用self（本身），super（上一级）或当前模块的标识符

路径至少由一个标识符组成，标识符之间使用::。

举个例子（下面这段程序将报错，我们将在后面讲到如何解决）：

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    crate::front_of_house::hosting::add_to_waitlist();//绝对路径

    front_of_house::hosting::add_to_waitlist();//相对路径
}

那么为什么会报错呢？

我们查看报错的原因：module hosting is private，编译器告诉我们，hosting这个module是私有的。至此，为了解决这个问题，我们应该去了解一下私有边界。

私有边界（private boundary）

• 模块不仅可以组织代码，还可以定义私有边界
• 如果把函数或struct等设为私有，可以将它放到某个模块中。
• rust中所有的条目（函数，方法，struct，enum，模块，常量）默认情况下是私有的
• 父级模块无法访问子模块中的私有条目
• 但是在子模块中可以使用所有祖先模块中的条目

为什么rust默认这些条目是私有的呢？因为rust希望能够隐藏内部的实现细节，这样就会让开发者明确知道：更改哪些内部代码的时候，不会破坏外部的代码。同时，我们可以使用pub关键字将其声明为公共的。

pub关键字

rust默认这些条目为私有的，我们可以使用pub关键字来将某些条目标记为公共的。

我们将hosting声明pub，add_to_waitlist这个function也要声明pub

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

pub fn eat_at_restaurant() {
    crate::front_of_house::hosting::add_to_waitlist();//绝对路径

    front_of_house::hosting::add_to_waitlist();//相对路径
}

为什么front_of_house这个mod不需要添加pub呢？因为它们是同级的。

super关键字

super：用来访问父级模块路径中的内容，类似文件系统中的..

fn serve_order() {}
mod front_of_house {
    fn fix_incorrect_order() {
        cook_order();
        super::serve_order();
    }
    fn cook_order() {}
}

pub struct

声明一个公共的struct就是将pub放在struct前：

mod back_of_house {
    pub struct Breakfast {}
}

声明了一个公共的struct后：

• struct是公共的
• struct的字段默认是私有的

而我们想让struct中的字段为公有的必须在前面加上pub：

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,      //公有的
        seasonal_fruit: String, //私有的
    }
}

也就是说：struct的字段需要单独设置pub来变成公有

我们看一个例子：

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,      //公有的
        seasonal_fruit: String, //私有的
    }

    impl Breakfast {
        //一个关联函数
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}

pub fn eat_at_restaurant() {
    let mut meal = back_of_house::Breakfast::summer("Rye");
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);
    meal.seasonal_fruit = String::from("blueberries");//报错：field `seasonal_fruit` is private
}

pub enum

声明一个公共的enum就是将pub放在enum前：

mod back_of_house {
    pub enum Appetizer {}
}

我们声明了一个公共的enum后：

• enum是公共的
• enum的变体也都是公共的

mod back_of_house {
    pub enum Appetizer {
        Soup,  //公共的
        Salad, //公共的
    }
}

为什么呢？因为枚举里面只有变体，只有变体是公共的这个枚举才有用。而struct中某些部分为私有的也不影响struct的使用，所以rust规定公共的struct中的字段默认为私有的。

Use关键字

我们可以使用use关键字将路径导入到作用域内，而我们引入的东西也任然遵循私有性规则（公共的引入的才能用）

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
        fn some_function() {}//私有的，使用use导入后，外部依然不能调用这个函数
    }
}

use crate::front_of_house::hosting;
// 相当于mod hosting {}

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
    hosting::add_to_waitlist();
}

使用use来指定相对路径（和使用条目时的规则相同）：

use front_of_house::hosting;

我们可以注意到我们调用的add_to_waitlist是导入的hostingmod下的，那我们可不可以直接导入function呢？

当然是可以的（不过并不推荐直接导入方法）：

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting::add_to_waitlist;
// 相对于mod hosting {}

pub fn eat_at_restaurant() {
    add_to_waitlist();
}

use的习惯用法

当我们直接导入方法时，我们有可能就搞不清楚是从其他模块导入的还是在这个作用域下声明的。

所以，通常情况下，我们导入的通常为父级模块。

//...
use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

不过，struct，enum，其他：指定完整路径（指定到本身）

use std::collections::HashMap;
fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}

但是同名的条目，我们在引入时需指定父级模块（比如下面的例子，两个类型都叫Result）

use std::fmt;
use std::io;

fn f1() -> fmt::Result {
    //...
}

fn f2() -> io::Result {
    //...
}
//...

as关键字

关于上面同名的问题，还有另一种解决方法：使用as关键字

as关键字可以为引入的路径指定本地的别名

use std::fmt::Result;
use std::io::Result as IoResult;

fn f1() -> Result {
    //...
}

fn f2() -> IoResult {
    //...
}