Rust-Programmierung | Dateihierarchie | Modulsichtbarkeit

Einführung

In diesem Lab kann die Dateihierarchie der Module im Codebeispiel wie folgt dargestellt werden: Es gibt ein Verzeichnis namens "my", das zwei Dateien enthält, "inaccessible.rs" und "nested.rs". Darüber hinaus gibt es eine Datei namens "my.rs" und eine Datei namens "split.rs". Die Datei "split.rs" enthält das Modul "my", das in der Datei "my.rs" definiert ist, und die Datei "my.rs" enthält die Module "inaccessible" und "nested", die in den Dateien "inaccessible.rs" und "nested.rs" definiert sind.

Hinweis: Wenn das Lab keinen Dateinamen angibt, können Sie einen beliebigen Dateinamen verwenden. Beispielsweise können Sie main.rs verwenden und es mit rustc main.rs &&./main kompilieren und ausführen.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/DataStructuresandEnumsGroup(["Data Structures and Enums"]) rust(("Rust")) -.-> rust/ProjectManagementandOrganizationGroup(["Project Management and Organization"]) rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust/FunctionsandClosuresGroup -.-> rust/function_syntax("Function Syntax") rust/FunctionsandClosuresGroup -.-> rust/expressions_statements("Expressions and Statements") rust/DataStructuresandEnumsGroup -.-> rust/method_syntax("Method Syntax") rust/ProjectManagementandOrganizationGroup -.-> rust/module_system("Module System") subgraph Lab Skills rust/function_syntax -.-> lab-99336{{"Modulare Rust-Dateiorganisation"}} rust/expressions_statements -.-> lab-99336{{"Modulare Rust-Dateiorganisation"}} rust/method_syntax -.-> lab-99336{{"Modulare Rust-Dateiorganisation"}} rust/module_system -.-> lab-99336{{"Modulare Rust-Dateiorganisation"}} end

Dateihierarchie

Module können in eine Datei-/Verzeichnis-Hierarchie abgebildet werden. Betrachten wir das Beispiel zur Sichtbarkeit in Dateien:

$ tree.
.
├── my
│   ├── inaccessible.rs
│   └── nested.rs
├── my.rs
└── split.rs

In split.rs:

// Diese Deklaration sucht nach einer Datei namens `my.rs` und
// fügt deren Inhalt in ein Modul namens `my` innerhalb dieses Bereichs ein
mod my;

fn function() {
    println!("aufgerufen `function()`");
}

fn main() {
    my::function();

    function();

    my::indirect_access();

    my::nested::function();
}

In my.rs:

// Ähnlich werden `mod inaccessible` und `mod nested` die Dateien `nested.rs`
// und `inaccessible.rs` finden und hier unter ihren jeweiligen Modulen einfügen
mod inaccessible;
pub mod nested;

pub fn function() {
    println!("aufgerufen `my::function()`");
}

fn private_function() {
    println!("aufgerufen `my::private_function()`");
}

pub fn indirect_access() {
    print!("aufgerufen `my::indirect_access()`, das\n> ");

    private_function();
}

In my/nested.rs:

pub fn function() {
    println!("aufgerufen `my::nested::function()`");
}

#[allow(dead_code)]
fn private_function() {
    println!("aufgerufen `my::nested::private_function()`");
}

In my/inaccessible.rs:

#[allow(dead_code)]
pub fn public_function() {
    println!("aufgerufen `my::inaccessible::public_function()`");
}

Überprüfen wir, ob alles weiterhin wie zuvor funktioniert:

$ rustc split.rs &&./split
aufgerufen `my::function()`
aufgerufen `function()`
aufgerufen `my::indirect_access()`, das
> aufgerufen `my::private_function()`
aufgerufen `my::nested::function()`

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab zu Dateihierarchien abgeschlossen. Sie können in LabEx weitere Labs absolvieren, um Ihre Fähigkeiten zu verbessern.