Rust之use关键字、* 运算符、super关键字

当调用模块的函数时，需要指定完整的路径。
通过下面一个例子来理解这个概念：

pub mod a  
{  
  pub mod b  
  {  
    pub mod c  
    {  
      pub fn nested_function()  
      {  
        println!("Nested function");  
      }  
    }  
  }  
 }  

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

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

Nested function

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

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

pub mod a  
{  
  pub mod b  
  {  
    pub mod c  
    {  
      pub fn nested_function()  
      {  
        println!("Nested function");  
      }  
    }  
  }  
 }  

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

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

Nested function

在上面的示例中，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();  
}

输出结果如下：

5

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

https://www.bootwiki.com/rust/rust-module-use-keyword.html