橘子味的心

    • 二十五岁时我们都一样愚蠢、多愁善感，喜欢故弄玄虚，可如果不那样的话，五十岁时也就不会如此明智。

    标题：Rust文件系统

    模块形成层次结构，使项目变得更容易理解。 Rust模块系统用于分割多个文件，使得并非所有内容都位于src/lib.rs或src/main.rs文件中。

    文件名：src/lib.rs 

    1. mod A  
    2. {  
    3.      fn a()  
    4.      {  
    5.           // block of statements.  
    6.      }  
    7. }    
    8. mod B  
    9. {  
    10.      fn b()  
    11.      {  
    12.             // block of statements.    
    13.      }  
    14.    mod C  
    15.   {  
    16.        fn c()  
    17.        {  
    18.              // block of statements.  
    19.        }  
    20.   }    
    21. }
    22. Rust

    在上面的例子中，程序由三个模块组成，即A，B和C。C是B模块的内部模块。

    给定文件的模块层次结构是：

    如果模块包含许多函数并且函数非常冗长，则很难找到特定函数的代码。 Rust通过提供模块系统提供了灵活性。可以拥有每个模块的单独文件，而不是放在同一个文件中，即src/lib.rs。

    要遵循的步骤：
    首先，用分号替换模块A。

    1. mod A;  
    2. mod B  
    3. {  
    4.      fn b()  
    5.      {  
    6.             // block of statements.    
    7.      }  
    8.      mod C  
    9.     {  
    10.        fn c()  
    11.        {  
    12.              // block of statements.  
    13.        }  
    14.      }    
    15. }
    16. Rust

    分号;表示Rust找到模块A的定义到另一个定义模块A范围的位置。

    模块A; 如下：

    1. mod A  
    2. {  
    3.      fn a()  
    4.      {  
    5.           // block of statements.  
    6.      }  
    7. }
    8. Rust

    现在创建包含模块A定义的外部文件。外部文件的名称将命名为 - src/A.rs。 创建文件后，在此文件中写入模块A的定义，该文件先前已被删除。

    文件名：src/A.rs 。

    1. fn a()  
    2.     // block of statements.
    3. Rust

    在这种情况下，不需要像在src/lib.rs 文件中提到的那样编写mod声明。 并且，如果在这里编写mod声明，那么它将成为模块A的子模块。

    Rust默认情况下会查看src/lib.rs 文件，然后该文件确定要进一步查看哪个文件。

    现在，从文件src/lib.rs中提取模块B，并用分号替换模块B的主体。

    文件名：src/lib.rs 

    1. mod A;  
    2. mod B;
    3. Rust

    mod B; 的代码如下：

    1. mod B  
    2.  
    3.     fn b()  
    4.     {  
    5.            // block of statements.    
    6.     }  
    7.   mod C  
    8.  {  
    9.       fn c()  
    10.       {  
    11.             // block of statements.  
    12.       }  
    13.  }
    14. Rust

    现在创建包含模块B定义的外部文件。外部文件的名称将命名为 - src/B.rs。 创建文件后，在此文件中写入先前已删除的模块B的定义。

    文件名：src/B.rs

    1. fn b()  
    2.     {  
    3.            // block of statements.    
    4.     }  
    5.       mod C  
    6.      {  
    7.           fn c()  
    8.           {  
    9.                 // block of statements.  
    10.           }  
    11.      }
    12. Rust

    现在将从文件src/B.rs中提取模块C，并用分号替换模块C的主体。

    1. fn b()  
    2.      {  
    3.             // block of statements.    
    4.      }  
    5. mod C;
    6. Rust

    mod C; 的代码如下所示 ：

    1. mod C  
    2. {  
    3.      fn c()  
    4.      {  
    5.            // block of statements.  
    6.      }  
    7. }
    8. Rust

    现在创建包含模块C定义的外部文件。外部文件的名称将命名为src/C.rs。 创建文件后，在此文件中写入模块C的定义，该文件先前已被删除。

    文件名称 : src/C.rs 

    1. fn c()  
    2.       {  
    3.             // block of statements.  
    4.       }
    5. Rust

    注意：从模块B中提取模块C将导致编译错误，因为src/B.rs与src/lib.rs不同。 因此，src/B.rs将被移动到一个新目录并重命名为src/B/mod.rs，然后将子模块移动到新的B目录中。

    模块文件系统规则：

    • 如果模块名为“server”且没有子模块，则模块的所有声明都可以放在文件server.rs中。
    • 如果名为“server”的模块包含子模块，则模块的所有声明都将放在文件server/mod.rs中。

    目录

    分类

    © 2020-2025 橘子味的心

  • 黔ICP备17008247号-2
  • 贵公网安备52022102000140