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();  
}

輸出結果如下 -

在上面的範例中，模組範例使用了參照其父模組的super。由於這個原因，模組範例的foo()函式可以存取模組a的私有函式。