《深入Rust系统编程》3.1 模块系统与包管理

3.1 模块系统与包管理

Rust 的模块系统和包管理机制是其组织代码和管理依赖的核心。模块系统允许开发者将代码组织成层次结构，而包管理机制则允许开发者轻松地使用和管理第三方库。

3.1.1 模块系统

Rust 的模块系统允许开发者将代码组织成层次结构，以提高代码的可读性、可维护性和可重用性。

1. 定义模块:

可以使用 mod 关键字定义模块：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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() {}
    }
}

2. 访问模块:

可以使用路径访问模块中的项：

1
2
3

fn main() {
    crate::front_of_house::hosting::add_to_waitlist();
}

3. pub 关键字:

可以使用 pub 关键字将模块或项标记为公开，使其可以在模块外部访问：

1
2
3
4
5
6
7
8
9

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

fn main() {
    crate::front_of_house::hosting::add_to_waitlist();
}

4. use 关键字:

可以使用 use 关键字将路径引入作用域，以简化代码：

1
2
3
4
5

use crate::front_of_house::hosting;

fn main() {
    hosting::add_to_waitlist();
}

5. 嵌套路径:

可以使用嵌套路径将多个项引入作用域：

1

use std::{cmp::Ordering, io};

6. self 和 super:

可以使用 self 和 super 关键字引用当前模块和父模块：

1
2
3

fn serve_order() {
    super::front_of_house::serving::take_order();
}

7. 将模块拆分为多个文件:

可以将模块拆分为多个文件，并使用 mod 关键字将文件引入模块：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// src/front_of_house.rs
pub mod hosting {
    pub fn add_to_waitlist() {}
}

// src/lib.rs
mod front_of_house;

fn main() {
    crate::front_of_house::hosting::add_to_waitlist();
}

3.1.2 包管理

Rust 使用 Cargo 作为其包管理工具。Cargo 可以用于创建、构建、测试和发布 Rust 项目，以及管理项目依赖。

1. 创建新项目:

可以使用 cargo new 命令创建新项目：

1

cargo new my_project

2. 项目结构:

新创建的项目包含以下文件和目录：

  • Cargo.toml: 项目的配置文件，包含项目元数据和依赖信息。
  • src/main.rs: 项目的入口文件，包含 main 函数。
  • src/lib.rs: 库项目的入口文件，包含库的公共 API。

3. 添加依赖:

可以在 Cargo.toml 文件的 [dependencies] 部分添加依赖：

1
2

[dependencies]
rand = "0.8.5"

4. 构建项目:

可以使用 cargo build 命令构建项目：

1

cargo build

5. 运行项目:

可以使用 cargo run 命令运行项目：

1

cargo run

6. 测试项目:

可以使用 cargo test 命令测试项目：

1

cargo test

7. 发布项目:

可以使用 cargo publish 命令发布项目到 crates.io：

1

cargo publish

3.1.3 代码实例

1. 定义模块:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// src/lib.rs
mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {
            println!("Added to waitlist");
        }
    }
}

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

2. 访问模块:

1
2
3
4
5
6

// src/main.rs
use my_project::eat_at_restaurant;

fn main() {
    eat_at_restaurant();
}

3. 将模块拆分为多个文件:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// src/front_of_house.rs
pub mod hosting {
    pub fn add_to_waitlist() {
        println!("Added to waitlist");
    }
}

// src/lib.rs
mod front_of_house;

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

4. 添加依赖:

1
2
3

# Cargo.toml
[dependencies]
rand = "0.8.5"

5. 使用依赖:

1
2
3
4
5
6
7

// src/main.rs
use rand::Rng;

fn main() {
    let secret_number = rand::thread_rng().gen_range(1..101);
    println!("The secret number is: {}", secret_number);
}

3.1.4 总结

Rust 的模块系统和包管理机制是其组织代码和管理依赖的核心。模块系统允许开发者将代码组织成层次结构，以提高代码的可读性、可维护性和可重用性。包管理机制允许开发者轻松地使用和管理第三方库。掌握 Rust 的模块系统和包管理机制，可以编写出更清晰、更易维护的 Rust 代码。

以下是一些学习 Rust 模块系统和包管理的资源：