In Rust bietet das Modul std::os eine Abstraktion über die Funktionalität des Betriebssystems. Es ermöglicht uns, mit dem zugrunde liegenden Betriebssystem zu interagieren, um mit Umgebungsvariablen, Dateisystemvorgängen, Prozessverwaltung und mehr zu arbeiten.
In diesem Beispiel behandeln wir einige grundlegende Vorgänge, die Sie unter Unix mit dem Rust-Modul std::os ausführen können.
Denken Sie daran, dass es sich um ein umfangreiches Modul handelt, das viele Typen und Funktionen für verschiedene Unix-bezogene Vorgänge enthält. Bitte beachten Sie daher die Dokumentation als Referenz zu den entsprechenden Prozessen.
Rust-Betriebssystem unter Linux
Unter Linux können wir auf die Unix-spezifischen Funktionen und Typen zugreifen, die vom Modul std::os::unix bereitgestellt werden, einem Untermodul des Moduls std::os in Rust.
Dieses Modul ist Teil der Rust-Standardbibliothek und erfordert daher keine Installation externer Crates oder Abhängigkeiten.
Lassen Sie uns mit diesem Modul einige grundlegende APIs und Vorgänge behandeln, die wir auf einem Linux-System ausführen können.
Zugriff auf die Umgebungsvariablen
Auf die Umgebungsvariablen können wir mit dem Modul std::env zugreifen. Beispielsweise ruft std::env::var(„PATH“) den Wert der Umgebungsvariablen PATH ab.
Betrachten Sie das folgende Beispielprogramm:
benutze std::env;benutze std::ffi::OsString;
fn Hand ( ) {
// Greifen Sie auf eine bestimmte Umgebungsvariable zu
Wenn lassen OK ( Wert ) = env::var ( „WAYLAND_DISPLAY“ ) {
println ! ( „WAYLAND_DISPLAY={}“ , Wert ) ;
}
// Iterieren Sie alle Umgebungsvariablen
für ( Schlüsselwert ) In env::wars_us ( ) {
lassen key_string = key.to_string_lossy ( ) ;
lassen value_string = value.to_string_lossy ( ) ;
println ! ( „{}:{}“ , Schlüsselzeichenfolge, Wertzeichenfolge ) ;
}
// Greifen Sie auf eine bestimmte Umgebungsvariable zu als ein ` OsString `
Wenn lassen Manche ( Wert ) = env::var_us ( „HOSTTYPE“ ) {
// Konvertieren ` OsString ` zu einem ` Zeichenfolge ` Wenn erforderlich
Wenn lassen Manche ( value_str ) = value.to_str ( ) {
println ! ( „HOSTTYPE={}“ , value_str ) ;
}
}
}
Im gegebenen Beispiel beginnen wir mit dem Import der notwendigen Module. In diesem Fall interessieren uns der std::env und der std::ff::OsString.
Um auf eine bestimmte Umgebungsvariable zuzugreifen, können wir die Funktion env::var verwenden und den Namen des Werts übergeben, den wir abrufen möchten. In diesem Fall erhalten wir den Wert der Variablen WAYLAND_DISPLAY.
Die Funktion gibt den Wert der Variablen als Ergebnistyp zurück.
Wir können auch alle Umgebungsvariablen mit der Funktion env::vars_os durchlaufen. Dies gibt einen Iterator mit den Schlüssel-Wert-Paaren der Umgebungsvariablen zurück. Beachten Sie, dass die Werte als OsString-Typ zurückgegeben werden. Wir können sie dann mit der Funktion to_string_lossy in String-Werte konvertieren.
Wir können auch mit der Funktion env::var_os auf die spezifischen Umgebungsvariablen zugreifen. Dies sollte einen Typ
Die resultierende Ausgabe lautet wie folgt:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
FS-Operationen mit dem OS-Modul
Wie Sie sich vorstellen können, bietet das Betriebssystemmodul verschiedene Funktionen und Methoden zur Durchführung dateisystembezogener Vorgänge.
Nehmen Sie das folgende Programm, das die verschiedenen Vorgänge demonstriert, die wir mit dem std::os-Modul unter Linux ausführen können:
benutze std::fs;fn Hand ( ) {
// Lesen ein Datei
Wenn lassen OK ( Inhalt ) = fs::read_to_string ( „/home/debian/.bashrc“ ) {
println ! ( „bashrc: {}“ , Inhalt ) ;
}
// Erstellen Sie ein neues Verzeichnis
Wenn lassen Irren ( irren ) = fs::create_dir ( „/home/debian/new_dir“ ) {
eprintln ! ( „Verzeichnis konnte nicht erstellt werden: {}“ , irren ) ;
}
// Entfernen Sie a Datei
Wenn lassen Irren ( irren ) = fs::remove_file ( „/home/debian/remove_me.txt“ ) {
eprintln ! ( „Fehler beim Entfernen der Datei: {}“ , irren ) ;
}
}
Im gegebenen Beispiel zeigen wir, wie wir den Inhalt einer Datei mit der Methode fs::read_to_string() lesen können. Die Methode übernimmt den Pfad zur Zieldatei und gibt den Dateiinhalt als String zurück.
Wir können auch ein neues Verzeichnis erstellen, indem wir die Funktion fs::create_dir() verwenden und den Pfad zum Zielverzeichnis als Parameter übergeben.
Schließlich können wir eine bestimmte Datei mit der Funktion fs::remove_file() entfernen und die Zieldatei als Parameter übergeben.
NOTIZ: Bei den bereitgestellten Beispielen handelt es sich um einige grundlegende Beispiele für die Ausführung der Dateisystemoperationen unter Linux mithilfe des Moduls std::fs. Rust bietet eine umfassende Sammlung von Methoden und Funktionen, die hier demonstriert werden. Weitere Informationen finden Sie in der Dokumentation.
Prozessmanagement mit dem OS-Modul
Wie Sie sich vorstellen können, bietet das Betriebssystemmodul Submodule und Funktionen für die Arbeit mit Prozessen im System.
Nehmen Sie den folgenden Beispielcode:
Verwenden Sie std::process:: { Befehl, Ausfahrt } ;fn Hand ( ) {
// Führen Sie die aus ls Befehl
lassen Ausgabe = Befehl::neu ( „ls“ )
.arg ( '-Die' )
.Ausgang ( )
.erwarten ( „Befehl konnte nicht ausgeführt werden“ ) ;
Wenn Ausgabe.Status.Erfolg ( ) {
lassen stdout = String::from_utf8_lossy ( & Ausgabe.stdout ) ;
println ! ( „Befehlsausgabe: \N {}' , Standard ) ;
} anders {
lassen stderr = String::from_utf8_lossy ( & Ausgabe.stderr ) ;
eprintln ! ( „Befehl fehlgeschlagen: \N {}' , stderr ) ;
Ausfahrt ( 1 ) ;
}
}
Im gegebenen Beispiel beginnen wir mit dem Import der benötigten Module. In diesem Fall benötigen wir die Methoden „command“ und „exit“ aus dem Submodul std::process.
Anschließend verwenden wir die Funktion Command::new(), um den Befehl „ls“ auszuführen und die Argumente an den Befehl zu übergeben.
Bei Erfolg sollte der Befehl die Verzeichnisliste für das aktuelle Arbeitsverzeichnis wie folgt zurückgeben:
Abschluss
Wir haben untersucht, wie Sie die verschiedenen Funktionen und Methoden verwenden können, die vom Modul std::os und den Submodulen bereitgestellt werden, um mehrere Vorgänge in Linux- und Unix-ähnlichen Systemen auszuführen. Denken Sie daran, dass das Modul std::os ein umfangreiches Modul ist, das eine breitere Sammlung von Funktionen enthält als die, die in diesem Tutorial demonstriert werden.