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

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

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

pub mod a  
{  
  pub mod b  
  {  
    pub mod c  
    {  
      pub fn nested_modules()  
      {  
        println!("Nested Modules");  
      }  
    }  
  }  
 }  

fn main()  
{  
 a::b::c::nested_modules();  
}

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

Nested Modules

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

use关键字

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

pub mod a  
{  
  pub mod b  
  {  
    pub mod c  
    {  
      pub fn nested_modules()  
      {  
        println!("Nested Modules");  
      }  
    }  
  }  
 }  

use a::b::c::nested_modules;  
fn main()  
{  
  nested_modules();  
}

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

Nested Modules

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

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

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

#[derive(Debug)]  
enum Flagcolor  
{  
 Orange,  
 White,  
 Green,  
}  
use Flagcolor::{Orange,White,Green};  
fn main()  
{  
  let _o= Orange;  
  let _w= White;  
  let _g= Green;  
  println!("{:?}",_o);  
  println!("{:?}",_w);  
  println!("{:?}",_g);  
}

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

orange
white
green

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

使用 * 运算符

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

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

#[derive(Debug)]  
enum Color  
{  
  Red,  
  Yellow,  
  Green,  
  Orange,  
}  

use Color::*;  
fn main()  
{  
  let _red=Red;  
  let _yellow=Yellow;  
  let _green=Green;  
  let _orange=Orange;  
  println!("{:?}",_red);  
  println!("{:?}",_yellow);   
  println!("{:?}",_green);  
  println!("{:?}",_orange);  
}

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

Red
Yellow
Green
Orange

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

使用 super 关键字

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

mod a{  
    fn x() -> u8 {  
        5  
    }  

    pub mod example {  
        use super::x;  

        pub fn foo() {  
            println!("{}",x());  
        }  
    }
}  

fn main()  
{  
  a::example::foo();  
}

输出结果如下 -

2

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