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的私有函數。