橘子味的心

    • 二十五岁时我们都一样愚蠢、多愁善感，喜欢故弄玄虚，可如果不那样的话，五十岁时也就不会如此明智。

    标题：Rust use关键字引用模块

    当调用模块的函数时，需要指定完整的路径。

    通过下面一个例子来理解这个概念：

    1. pub mod a  
    2. {  
    3.   pub mod b  
    4.   {  
    5.     pub mod c  
    6.     {  
    7.       pub fn nested_modules()  
    8.       {  
    9.         println!("Nested Modules");  
    10.       }  
    11.     }  
    12.   }  
    13.  }  
    14.  
    15. fn main()  
    16. {  
    17.  a::b::c::nested_modules();  
    18. }
    19. Rust

    执行上面示例代码，得到以下结果 - 

    1. Nested Modules
    2. Shell

    在上面的例子中，通过指定完整路径来调用nested_modules()函数，即，a::b::c::nested_modules()。

    use关键字

    在上面的场景中，看到函数调用非常冗长。 Rust中的use关键字缩短了调用函数的长度，使函数的模块在范围内。 use关键字只在范围中指定的那些模块。 通过下面一个例子来理解这一点：

    1. pub mod a  
    2. {  
    3.   pub mod b  
    4.   {  
    5.     pub mod c  
    6.     {  
    7.       pub fn nested_modules()  
    8.       {  
    9.         println!("Nested Modules");  
    10.       }  
    11.     }  
    12.   }  
    13.  }  
    14.  
    15. use a::b::c::nested_modules;  
    16. fn main()  
    17. {  
    18.   nested_modules();  
    19. }
    20. Rust

    执行上面示例代码，得到以下结果 - 

    1. Nested Modules
    2. Shell

    在上面的示例中，use关键字包括范围内的所有模块。 因此，可以直接调用函数，而不必在调用函数中包含模块。

    枚举也是模块之类的命名空间的一种形式。 因此，可以使用use关键字将枚举变体带入范围。 在use语句中，可以列出大括号中的枚举变体和最后位置的逗号。

    通过下面一个例子来理解：

    1. #[derive(Debug)]  
    2. enum Flagcolor  
    3. {  
    4.  Orange,  
    5.  White,  
    6.  Green,  
    7. }  
    8. use Flagcolor::{Orange,White,Green};  
    9. fn main()  
    10. {  
    11.   let _o= Orange;  
    12.   let _w= White;  
    13.   let _g= Green;  
    14.   println!("{:?}",_o);  
    15.   println!("{:?}",_w);  
    16.   println!("{:?}",_g);  
    17. }
    18. Rust

    执行上面示例代码，得到以下结果：

    1. orange
    2. white
    3. green
    4. Shell

    在上面的示例中，Flagcolor是一个名称空间，其变体在use语句中指定。 因此，可以直接使用枚举变体而不使用枚举名称和名称空间说明符。

    使用 * 运算符

    *运算符用于将所有项目放入范围，这也称为glob运算符。 如果使用glob运算符，那么不需要单独指定枚举变量。

    通过下面一个例子来理解这一点：

    1. #[derive(Debug)]  
    2. enum Color  
    3. {  
    4.   Red,  
    5.   Yellow,  
    6.   Green,  
    7.   Orange,  
    8. }  
    9.  
    10. use Color::*;  
    11. fn main()  
    12. {  
    13.   let _red=Red;  
    14.   let _yellow=Yellow;  
    15.   let _green=Green;  
    16.   let _orange=Orange;  
    17.   println!("{:?}",_red);  
    18.   println!("{:?}",_yellow);   
    19.   println!("{:?}",_green);  
    20.   println!("{:?}",_orange);  
    21. }
    22. Rust

    执行上面示例代码，得到以下结果 - 

    1. Red
    2. Yellow
    3. Green
    4. Orange
    5. Shell

    在上面的示例中，*运算符已用于包含所有枚举变体，而无需在use语句中指定列表。

    使用 super 关键字

    super关键字用于从当前模块访问父模块，它使能够访问父模块的私有功能。

    1. mod a{  
    2.     fn x() -> u8 {  
    3.         5  
    4.     }  
    5.  
    6.     pub mod example {  
    7.         use super::x;  
    8.  
    9.         pub fn foo() {  
    10.             println!("{}",x());  
    11.         }  
    12.     }
    13. }  
    14.  
    15. fn main()  
    16. {  
    17.   a::example::foo();  
    18. }
    19. Rust

    输出结果如下 - 

    1. 2
    2. Shell

    在上面的示例中，模块示例使用了引用其父模块的super。 由于这个原因，模块示例的foo()函数可以访问模块a的私有函数。


    目录

    分类

    © 2020-2025 橘子味的心

  • 黔ICP备17008247号-2
  • 贵公网安备52022102000140