Rust-Projekte mit Paketen, Pfaden und Modulen organisieren

Rust ist eine ausgezeichnete Wahl für den Aufbau komplexer und zuverlässiger Anwendungen. Eine der wesentlichen Fähigkeiten für die Entwicklung von Rust-Anwendungen ist die effektive Strukturierung Ihrer Projekte, einschließlich der Einbindung von Paketen von Drittanbietern.

Eine effektive Projektorganisation ist entscheidend für die Entwicklung von Rust-Anwendungen. Gut strukturierte Rust-Apps verbessern die Zusammenarbeit und die einfache Integration von Drittanbieter-Apps, wodurch der Zeit- und Arbeitsaufwand für die App-Entwicklung erheblich reduziert wird. Rust bietet einen integrierten Paketmanager und andere Tools für eine effektive Codeorganisation und -verwaltung.

Rust-Projekte einrichten

Das Einrichten von Rust-Projekten ist einfach Sobald Sie Rust auf Ihrem Computer installiert haben; Sie können Cargo (den integrierten Paketmanager und das Build-System von Rust) verwenden, um ein Rust-Projekt zu erstellen und zu konfigurieren. Es ist ähnlich wie bei anderen Paketmanagern wie

npm für Node.js Und Pip für Python. Cargo verwaltet Abhängigkeiten, kompiliert Code und generiert Dokumentation, was es zu einem unverzichtbaren Werkzeug für die Entwicklung von Rust macht.

Führen Sie diesen Befehl aus, um Ihre Cargo-Installation zu überprüfen:

Fracht --Version

Der Befehl zeigt die installierte Cargo-Version an.

Sie können ein neues Rust-Projekt mit der erstellen Fracht neu Befehl. Sie müssen den Projektnamen angeben.

Fracht neu mein_Projekt

Der Befehl erstellt ein neues Verzeichnis im aktuellen Verzeichnis, das die grundlegenden Dateien enthält, die Sie für Ihr Rust-Projekt benötigen, einschließlich einer cargo.toml Datei zum Verwalten der Abhängigkeiten Ihres Projekts.

Der Namespace des Rust-Pakets

Pakete und Kisten sind wesentliche Bestandteile in Rust. Crates sind Bibliotheken oder Binärdateien, die die Rust-Entwickler für bestimmte Zwecke verwenden und kompilieren können, und Pakete sind eine Sammlung von Crates. Pakete enthalten normalerweise eine Kiste, die den wiederverwendbaren Code enthält, und eine Binärdatei, die eine CLI für die Bibliothekskiste bereitstellt.

Kisten müssen enthalten Fracht.toml Datei, die Metadaten zum Paket enthält, z. B. Name, Version, Abhängigkeiten und Erstellungsskripts.

Rust-Pakete folgen einer Namenskonvention, um Namenskonflikte zwischen Paketen zu vermeiden. Paketnamen müssen global eindeutig sein, Kleinbuchstaben enthalten und dürfen nur Buchstaben, Ziffern und Bindestriche enthalten. Wenn ein Paketname mehrere Wörter enthält, trennen Sie diese mit Bindestrichen, z. Hyperserver.

Sie können auf Code innerhalb eines Rust-Paket-Namensraums mit zugreifen verwenden Schlüsselwort, gefolgt von den Paket- und Kistennamen.

Hier ist ein Beispiel für den Import einer Rng Funktion von a Rand Kiste:

verwenden Rand:: Ring;

Sie können mehrere Namespaces für Pakete erstellen. Wenn Sie einen Ordner erstellen, erstellen Sie einen neuen Namespace, auf den Sie mit der Punktnotation zugreifen können, um den Pfad zum Bezeichner anzugeben.

In Rust kann es mehrere Namensräume für Pakete geben. Wenn Sie einen Ordner erstellen, erstellen Sie einen neuen Namespace. Um auf Code aus einem anderen Namespace zuzugreifen, verwenden Sie eine Punktnotation, um den Pfad zum Bezeichner anzugeben.

Hier ist ein Beispiel für den Zugriff auf eine Funktion aus einem anderen Namespace:

// Datei im Namensraum Ordner1
KneipefnOrdner() -> u32 {
// ein Funktionsrumpf hier
zurückkehren0;
}
// Datei im Namensraum Ordner2
verwenden Ordner1::Ordner;
KneipefnVerzeichnis() {
// Zugriff auf die Ordnerfunktion aus dem Ordnerordner1-Namespace
lassen folder_func = Ordner();
}

Das Programm definiert zwei Rust-Module in unterschiedlichen Namespaces, Ordner1 Und Ordner2 bzw. Der Ordner1 Modul enthält eine öffentliche Funktion Ordner die einen 32-Bit-Ganzzahlwert ohne Vorzeichen zurückgibt.

Der Ordner2 Modul importiert die Ordner Funktion aus der Ordner1 Namensraum mit der verwenden Stichwort, so dass die Verzeichnis Funktion für den Zugriff auf die Ordner Funktion aus der Ordner1 Modul. Der Verzeichnis Funktion ruft die auf Ordner Funktion, und der Rückgabewert wird der zugewiesen Ordner_Funktion Variable.

Sie müssen den Namen der Kennungen aus einem Paket oder einer Kiste groß schreiben, um sie zu exportieren. Wenn Sie einen Bezeichner exportieren, machen Sie ihn in anderen Paketen zugänglich, die den Code verwenden.

Hier ist ein Beispiel für eine öffentliche Funktion, die exportiert werden kann.

// Funktion in andere Pakete und Crates exportiert
KneipefnMeineFunktion() {
// ein Funktionsrumpf hier
}

Sie müssen auch die verwenden Kneipe Stichwort. In Rust, der Kneipe Schlüsselwort ist kurz für öffentlich. Wenn eine Funktion, eine Struktur, eine Aufzählung, jeder Rust-Datentyp oder Modul mit dem Schlüsselwort pub markiert ist, wird es außerhalb seines Moduls zugänglich. Das Element ist ohne das Schlüsselwort pub für sein Modul privat und kann nur von dort aus aufgerufen werden.

Definieren von Modulen zum Steuern von Umfang und Datenschutz

Sie können Module verwenden, um Umfang und Datenschutz in Rust-Programmen zu steuern. Mit Modulen können Sie Code in logische Einheiten organisieren, die einfacher zu verwalten und zu warten sind.

Sie können Module mit deklarieren Mod Schlüsselwort gefolgt vom Modulnamen und geschweiften Klammern. Das Definieren eines neuen Moduls erstellt einen neuen Namensraum für seinen Inhalt, was bedeutet, dass Funktionen, Strukturen oder andere innerhalb des Moduls definierte Elemente sind nur innerhalb des Moduls zugänglich, außer Sie exportieren explizit ihnen.

Module helfen dabei, Namenskonflikte zu vermeiden, wodurch der Code intuitiver verständlich wird.

Hier ist die Syntax für ein einfaches Modul:

Mod mein_modul {
// Modulinhalte kommen hierher
}

Innerhalb des Moduls können Sie Variablen, Funktionen, Strukturen, Aufzählungen und andere Typen definieren.

Mod mein_modul {
fnadd_numbers(A: i32, B: i32) -> i32 {
 a+b
 }
}

Du kannst den... benutzen Kneipe Schlüsselwort, um die Funktion zu exportieren und in anderen Teilen des Programms auf die Funktion zuzugreifen.

Mod mein_modul {
Kneipefnadd_numbers(A: i32, B: i32) -> i32 {
 a+b
 }
}

Jetzt können Sie anrufen add_numbers Funktion aus anderen Teilen Ihres Programms.

Sie können die Privatsphäre von Modulen auch mit steuern Kneipe Schlüsselwort auf Moduldefinitionen.

KneipeMod mein_modul {
Kneipefnadd_numbers(A: i32, B: i32) -> i32 {
 a+b
 }
}

Jetzt die mein_modul Das Modul ist öffentlich, und Sie können von anderen Modulen aus auf das Modul zugreifen.

Wenn Sie ein Modul oder Element für ein bestimmtes Modul oder eine Reihe von Modulen zugänglich machen müssen, können Sie die verwenden Kneipe (Kiste) Stichwort. Der Kneipe (Kiste) Das Schlüsselwort macht den Gegenstand von Modulen innerhalb derselben Kiste zugänglich, aber nicht von Modulen in anderen Kisten.

Mod mein_modul {
KneipeStrukturMeineStruktur {
Kneipe(Kiste) irgendein_feld: u32,
 }
}

Sie können jetzt auf das spezifische Element zugreifen (in diesem Fall die Irgendein_Feld Feld der MeineStruktur struct) in anderen Teilen Ihres Programms.

fnhauptsächlich() {
lassen my_struct = my_module:: MyStruct {some_field: 42 };
drucken!("{}", my_struct.some_field);
}

Der meine_struktur Variable ist eine Instanz von MeineStruktur Struktur. Die Variable greift mit dem Pfadtrennzeichen (::) auf die Struktur zu. Der hauptsächlich Funktion druckt die Irgendein_Feld Feld der Struktur mit dem drucken! Makro.

Das Eigentumsmodell von Rust gewährleistet Speichersicherheit

Das Organisieren von Rust-Code ist eine Möglichkeit, sicherzustellen, dass Ihr Code im Laufe der Zeit einfach zu warten und zu unterstützen ist. Es ist einfacher, Fehler zu beheben und die Sicherheit in gut organisiertem Code zu gewährleisten, der den Regeln und Konventionen der Rust-Community folgt.

Standardmäßig stellt Rust sicher, dass Programme mit einem eingebauten Eigentumsmodell speichersicher sind. Das Eigentümermodell gewährleistet Speichersicherheit, indem sichergestellt wird, dass Variablen im Speicher einen eindeutigen Eigentümer haben. Das Eigentumsmodell verhindert Datenspuren und viele Arten von Speicherfehlern.