• 模块与属性
    • 定义模块
    • 导入 crate
    • 属性

    模块与属性

    Rust有两个与模块 (module) 系统相关的独特术语:cratemodule
    其中包装箱 (crate) 与其它语言中的 libary 或者 package 作用一样。
    每个包装箱都有一个隐藏的根模块,在根模块下可以定义一个子模块树,
    其路径采用::作为分隔符。包装箱由条目 (item) 构成,多个条目通过模块组织在一起。

    定义模块

    使用mod关键字定义我们的模块:

    1. // in src/lib.rs
    2. mod chinese {
    3. mod greetings {
    4. }
    5. mod farewells {
    6. }
    7. }
    8. mod english {
    9. mod greetings {
    10. }
    11. mod farewells {
    12. }
    13. }

    定义了四个子模块chinese::{greetings, farewells}english::{greetings, farewells}
    模块默认是私有的,可以使用pub关键字将其设置成公开,只有公开的条目才允许在模块外部访问。

    实践中更好的组织方式是将一个包装箱分拆到多个文件:

    1. // in src/lib.rs
    2. pub mod chinese;
    3. pub mod english;

    这两句声明告诉Rust查看src/chinese.rssrc/english.rs
    或者src/chinese/mod.rssrc/english/mod.rs
    先添加一些函数:

    1. // in src/chinese/greetings.rs
    2. pub fn hello() -> String {
    3. "你好!".to_string()
    4. }
    1. // in src/chinese/farewells.rs
    2. pub fn goodbye() -> String {
    3. "再见!".to_string()
    4. }
    1. // in src/english/greetings.rs
    2. pub fn hello() -> String {
    3. "Hello!".to_string()
    4. }
    1. // in src/english/farewells.rs
    2. pub fn goodbye() -> String {
    3. "Goodbye!".to_string()
    4. }

    函数默认也是私有的,为了后面的使用我们需要pub关键字使其成为公有。

    导入 crate

    为了使用我们前面创建的名为phrases的包装箱,需要先声明导入

    1. // in src/main.rs
    2. extern crate phrases;
    3. fn main() {
    4. println!("Hello in Chinese: {}", phrases::chinese::greetings::hello());
    5. }

    Rust还有一个use关键字,允许我们导入包装箱中的条目到当前的作用域内:

    1. // in src/main.rs
    2. extern crate phrases;
    3. use phrases::chinese::greetings;
    4. use phrases::chinese::farewells::goodbye;
    5. fn main() {
    6. println!("Hello in Chinese: {}", greetings::hello());
    7. println!("Goodbye in Chinese: {}", goodbye());
    8. }

    但是,我们不推荐直接导入函数,这样更容易导致命名空间冲突,只导入模块是更好的做法。
    如果要导入来自同一模块的多个条目,可以使用大括号简写:

    1. use phrases::chinese::{greetings, farewells};

    如果是导入全部,可以使用通配符*。重命名可以使用as关键字:

    1. use phrases::chinese::greetings as chinese_greetings;

    有时我们需要将外部包装箱里面的函数导入到另一个模块内,
    这时可以使用pub use来提供扩展接口而不映射代码层级结构。
    比如

    1. // in src/english/mod.rs
    2. pub use self::greetings::hello;
    3. pub use self::farewells::goodbye;
    4. mod greetings;
    5. mod farewells;

    其中pub use声明将函数带入了当前模块中,
    使得我们现在有了phrases::english::hello()函数和phrases::english::goodbye()函数,
    即使它们的定义位于phrases::english::greetings::hello()
    phrases::english::farewells::goodbye()中,
    内部代码的组织结构不能反映我们的扩展接口。

    默认情况下,use声明表示从根包装箱开始的绝对路径。
    此外,我们可以使用use self::表示相对于当前模块的位置,
    use super::表示当前位置的上一级,以::为前缀的路径表示根包装箱路径。

    1. use foo::baz::foobaz; // foo is at the root of the crate
    2. mod foo {
    3. use foo::bar::foobar; // foo is at crate root
    4. use self::baz::foobaz; // self refers to module 'foo'
    5. pub mod bar {
    6. pub fn foobar() { }
    7. }
    8. pub mod baz {
    9. use super::bar::foobar; // super refers to module 'foo'
    10. pub fn foobaz() { }
    11. }
    12. }

    属性

    在Rust中,属性 (attribute) 是应用于包装箱、模块或者条目的元数据 (metadata),
    主要用于:

    • 实现条件编译 (conditional compilation)
    • 设置包装箱名字、版本以及类型
    • 取消可疑代码的警告
    • 设置编译器选项
    • 链接外部库
    • 标记测试函数

    属性有两种用法:#![crate_attribute]应用于整个包装箱,
    #[crate_attribute]应用于紧邻的一个模块或者条目。
    属性的参数也有三种不同的形式:

    • #[attribute = "value"]
    • #[attribute(key = "value")]
    • #[attribute(value)]

    下面列举几个经常用到的属性:

    • #[path="foo.rs"]用于设置一个模块需要载入的文件路径。
    • #[allow(dead_code)]用于取消对死代码的默认lint检查。
    • #[derive(PartialEq, Clone)]用于自动推导PartialEqClone这两个特性的实现。