引用不同模块中的名称

2024 年 8 月 29 日 | 阅读 3 分钟

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

让我们通过一个例子来理解这个概念

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

输出

在上面的例子中，模块 example 使用了 super，它引用了它的父模块。因此，模块 example 的 foo() 函数可以访问模块 a 的私有函数。

下一主题#

← prev next →