Rust-Organisationsverwaltung

Jede Programmiersprache, die Code nicht organisieren kann, wird schwer zu beherrschen sein; fast kein Softwareprodukt wird aus einer einzigen Quelldatei kompiliert.

Bis zu diesem Punkt in diesem Tutorial wurden alle Programme in einer einzigen Datei geschrieben, hauptsächlich um das Erlernen der Syntax und Konzepte von Rust zu erleichtern.

Für ein Projekt ist die Organisation des Codes sehr wichtig.

Rust hat drei wichtige Organisationskonzepte: Crate, Paket und Modul.

Crate

Ein "Crate" ist eine binäre Programmdatei oder eine Bibliotheksdatei, und es existiert in einem "Paket".

Ein "Crate" hat eine baumartige Struktur, und seine Wurzel ist das Programm, das aus der Quelldatei kompiliert wird, die der Compiler beim Start kompiliert.

Hinweis: Eine "binäre Programmdatei" ist nicht unbedingt eine "binäre ausführbare Datei"; es kann nur bestätigt werden, dass es sich um eine Datei handelt, die Zielmaschinensprache enthält, und das Dateiformat variiert je nach Kompilierungsumgebung.

Paket

Wenn wir Cargo verwenden, um den Befehl new auszuführen und ein Rust-Projekt zu erstellen, wird eine Cargo.toml-Datei im Projektverzeichnis erstellt. Das Wesen eines Projekts ist ein Paket. Ein Paket muss von einer Cargo.toml-Datei verwaltet werden, die die grundlegenden Informationen und Abhängigkeiten des Pakets beschreibt.

Ein Paket kann höchstens ein Bibliotheks-"Crate" enthalten, kann eine beliebige Anzahl binärer "Crates" enthalten, muss aber mindestens ein "Crate" enthalten (ob es sich um eine Bibliothek oder ein binäres "Crate" handelt).

Nachdem mit dem Befehl cargo new ein Paket erstellt wurde, wird eine main.rs-Quelldatei im Verzeichnis src generiert. Cargo behandelt diese Datei standardmäßig als Wurzel des binären Crates, und das kompilierte binäre Crate hat denselben Namen wie das Paket.

Modul

Für ein Softwareprojekt organisieren wir es oft gemäß den Organisationskonventionen der verwendeten Programmiersprache. Die Hauptstruktur zur Organisation von Modulen ist oft ein Baum. Die Haupteinheit zur Organisation funktionaler Module in Java ist die Klasse, während JavaScript Module hauptsächlich über Funktionen organisiert.

Die Organisationseinheiten dieser höheren Programmiersprachen können Ebene für Ebene verschachtelt werden, genau wie die Verzeichnisstruktur eines Dateisystems. Die Organisationseinheit in Rust ist das Modul (Module).

mod nation {
    mod government {
        fn govern() {}
    }
    mod congress {
        fn legislate() {}
    }
    mod court {
        fn judicial() {}
    }
}

Dies ist ein Programm, das ein Land beschreibt, das nach dem Rechtsstaatsprinzip regiert wird: die nation enthält government, congress und court, die jeweils exekutive, legislative und judikative Funktionen haben. Wir können dies in eine Baumstruktur umwandeln:

nation
 ├── government
 │ └── govern
 ├── congress
 │ └── legislate
 └── court
   └── judicial

In einem Dateisystem verwendet die Verzeichnisstruktur oft Schrägstriche in Pfadzeichenketten, um die Position von Objekten darzustellen. Der Pfadtrenner in Rust ist:: 。

Pfade werden in absolute Pfade und relative Pfade unterteilt. Absolute Pfade werden ausgehend vom Schlüsselwort crate beschrieben. Relative Pfade werden ausgehend vom Schlüsselwort self oder super oder von einem Bezeichner beschrieben. Zum Beispiel:

crate::nation::government::govern();

ist der absolute Pfad, der die govern-Funktion beschreibt. Der relative Pfad kann ausgedrückt werden als:

nation::government::govern();

Jetzt kannst du versuchen, eine ähnliche Modulstruktur in einem Quellprogramm zu definieren und Pfade in der main-Funktion zu verwenden.

Wenn du das tust, wirst du sicherlich feststellen, dass etwas nicht stimmt: Das government-Modul und die darin enthaltenen Funktionen sind alle privat, und du darfst nicht auf sie zugreifen.


Zugriffsberechtigungen

Rust hat zwei einfache Zugriffsberechtigungen: öffentlich und privat.

Standardmäßig ist die Zugriffsberechtigung von Mitgliedern in einem Modul privat, wenn kein Modifizierer hinzugefügt wird.

Wenn du öffentliche Berechtigung verwenden möchtest, musst du das Schlüsselwort pub verwenden.

Bei privaten Modulen kann nur von Positionen auf derselben Ebene oder auf niedrigeren Ebenen darauf zugegriffen werden; von außerhalb kann nicht darauf zugegriffen werden.

Beispiel

mod nation {
    pub mod government {
        pub fn govern() {}
    }

    mod congress {
        pub fn legislate() {}
    }
   
    mod court {
        fn judicial() {
            super::congress::legislate();
        }
    }
}

fn main() {
    nation::government::govern();
}

Dieses Programm kann kompiliert werden. Bitte achten Sie darauf, wie auf super im Modul court zugegriffen wird.

Wenn ein struct in einem Modul definiert ist, sind neben dem struct selbst auch seine Felder standardmäßig privat. Wenn Sie also ein struct und seine Felder aus einem Modul verwenden möchten, benötigen Sie die pub-Deklaration:

Beispiel

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("Pfirsiche"),
            }
        }
    }
}
pub fn eat_at_restaurant() {
    let mut meal = back_of_house::Breakfast::summer("Roggen");
    meal.toast = String::from("Weizen");
    println!("Ich hätte gern {} Toast, bitte", meal.toast);
}
fn main() {
    eat_at_restaurant()
}

Ausgabe:

I'd like Wheat toast please

Enum-Varianten können Felder enthalten, aber sie haben keine ähnliche Eigenschaft:

Beispiel

mod SomeModule {
    pub enum Person {
        King {
            name: String
        },
        Queen
    }
}

fn main() {
    let person = SomeModule::Person::King{
        name: String::from("Blue")
    };
    match person {
        SomeModule::Person::King {name} => {
            println!("{}", name);
        }
        _ => {}
    }
}

Ausgabe:

Blue

Versteckte Module

Entwickler, die Java verwendet haben, mögen den äußersten Klassenblock beim Programmieren oft nicht — sein Name ist genau derselbe wie der Dateiname, weil er den Dateicontainer darstellt. Obwohl er umständlich ist, müssen wir ihn einmal schreiben, um zu betonen, dass "diese Klasse die in der Datei enthaltene Klasse ist".

Dies hat jedoch einige Vorteile: Zumindest macht es Entwicklern die Existenz von Klassen-Wrapping deutlich bewusst, und es kann Klassenvererbungsbeziehungen klar beschreiben.

In Rust sind Module wie Klassen-Wrapper in Java, aber eine main-Funktion kann ganz am Anfang einer Datei geschrieben werden. Wie lässt sich das erklären?

Der Inhalt jeder Rust-Datei ist ein "verstecktes" Modul.

Lassen Sie uns zwei Dateien verwenden, um dies zu zeigen:

main.rs-Datei

// main.rs
mod second_module;

fn main() {
    println!("Dies ist das Hauptmodul.");
    println!("{}", second_module::message());
}

second_module.rs-Datei

// second_module.rs
pub fn message() -> String {
    String::from("Dies ist das 2. Modul.")
}

Ausgabe:

This is the main module.
This is the 2nd module.

use-Schlüsselwort

Mit dem use-Schlüsselwort können Modulbezeichner in den aktuellen Gültigkeitsbereich gebracht werden:

Beispiel

mod nation {
    pub mod government {
        pub fn govern() {}
    }
}

use crate::nation::government::govern;

fn main() {
    govern();
}

Dieses Programm lässt sich kompilieren.

Weil das use-Schlüsselwort den Bezeichner govern in das aktuelle Modul importiert, kann er direkt verwendet werden.

Dies löst das Problem übermäßig langer lokaler Modulpfade.

Natürlich gibt es in manchen Fällen zwei identische Namen, die ebenfalls importiert werden müssen. Wir können das as-Schlüsselwort verwenden, um dem Bezeichner einen Alias hinzuzufügen:

Beispiel

mod nation {
    pub mod government {
        pub fn govern() {}
    }
    pub fn govern() {}
}
   
use crate::nation::government::govern;
use crate::nation::govern as nation_govern;

fn main() {
    nation_govern();
    govern();
}

Hier gibt es zwei govern-Funktionen, eine unter nation und eine unter government. Wir verwenden as, um die unter nation mit dem Alias nation_govern zu versehen. Beide Namen können gleichzeitig verwendet werden.

Das Schlüsselwort use kann zusammen mit dem Schlüsselwort pub verwendet werden:

Beispiel

mod nation {
    pub mod government {
        pub fn govern() {}
    }
    pub use government::govern;
}

fn main() {
    nation::govern();
}

Verweisen auf die Standardbibliothek

Offizielle Rust-Standardbibliotheksdokumentation:https://doc.rust-lang.org/stable/std/all.html

Nachdem wir die Konzepte in diesem Kapitel gelernt haben, können wir ganz einfach Systembibliotheken importieren, um Programme bequem zu entwickeln:

Beispiel

use std::f64::consts::PI;

fn main() {
    println!("{}", (PI / 2.0).sin());
}

Ausgabe:

1

Alle Systembibliotheksmodule werden standardmäßig importiert. Um sie zu verwenden, müssen Sie lediglich das Schlüsselwort use verwenden, um Pfade für eine bequeme Nutzung zu vereinfachen.

Andere Erweiterungen