In Rust biedt de std::os-module een abstractie van de functionaliteit van het besturingssysteem. Het stelt ons in staat om te communiceren met het onderliggende besturingssysteem om te werken met de omgevingsvariabelen, bestandssysteembewerkingen, procesbeheer en meer.
In dit voorbeeld behandelen we enkele fundamentele bewerkingen die u op Unix kunt uitvoeren met behulp van de Rust std::os-module.
Het is goed om te onthouden dat dit een uitgebreide module is en veel typen en functies bevat voor diverse Unix-gerelateerde bewerkingen. Raadpleeg daarom de documentatie voor referentie over de overeenkomstige processen.
Roest OS in Linux
In Linux hebben we toegang tot de Unix-specifieke functies en typen die worden geleverd door de std::os::unix-module, een submodule van de std::os-module in Rust.
Deze module maakt deel uit van de Rust-standaardbibliotheek en vereist daarom geen externe kratten of afhankelijkheden.
Laten we enkele basis-API's en bewerkingen bespreken die we vanuit deze module op een Linux-systeem kunnen uitvoeren.
Toegang tot de omgevingsvariabelen
We hebben toegang tot de omgevingsvariabelen met behulp van de std::env module. std::env::var(“PATH”) haalt bijvoorbeeld de waarde op van de omgevingsvariabele PATH.
Beschouw het volgende voorbeeldprogramma:
gebruik std::env;gebruik std::ffi::OsString;
fn hand ( ) {
// Toegang tot een specifieke omgevingsvariabele
als laten OK ( waarde ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , waarde ) ;
}
// Herhaal alle omgevingsvariabelen
voor ( sleutel waarde ) in env::wars_us ( ) {
laten key_string = key.to_string_lossy ( ) ;
laten value_string = waarde.to_string_lossy ( ) ;
println ! ( '{}:{}' , key_string, waarde_string ) ;
}
// Toegang tot een specifieke omgevingsvariabele als een ` OsString `
als laten Sommige ( waarde ) = env::var_us ( 'HOSTTYPE' ) {
// Overzetten ` OsString ` naar een ` Snaar ` als nodig zijn
als laten Sommige ( waarde_str ) = waarde.naar_str ( ) {
println ! ( 'HOSTTYPE={}' , waarde_str ) ;
}
}
}
In het gegeven voorbeeld beginnen we met het importeren van de benodigde modules. In dit geval zijn we geïnteresseerd in de std::env en de std::ff::OsString.
Om toegang te krijgen tot een specifieke omgevingsvariabele, kunnen we de functie env::var gebruiken en de naam doorgeven van de waarde die we willen ophalen. In dit geval krijgen we de waarde van de variabele WAYLAND_DISPLAY.
De functie retourneert de waarde van de variabele als resultaattype.
We kunnen ook alle omgevingsvariabelen herhalen met behulp van de functie env::vars_os. Dit retourneert een iterator met de sleutelwaardeparen van de omgevingsvariabelen. Het is goed om op te merken dat de waarden worden geretourneerd als een OsString-type. We kunnen ze vervolgens converteren naar tekenreekswaarden met behulp van de functie to_string_lossy.
We hebben ook toegang tot de specifieke omgevingsvariabelen met behulp van de functie env::var_os. Dit zou een
De resulterende uitvoer is als volgt:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
FS-bewerkingen met behulp van de OS-module
Zoals u kunt raden, biedt de OS-module verschillende functies en methoden om de bestandssysteemgerelateerde bewerkingen uit te voeren.
Neem het volgende programma dat de verschillende bewerkingen demonstreert die we kunnen uitvoeren met behulp van de std::os-module in Linux:
gebruik std::fs;fn hand ( ) {
// Lees een bestand
als laten OK ( inhoud ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , inhoud ) ;
}
// Maak een nieuwe map aan
als laten Err ( fout ) = fs::maak_dir ( '/home/debian/nieuwe_dir' ) {
eprintln ! ( 'Kan map niet maken: {}' , fout ) ;
}
// Verwijder een bestand
als laten Err ( fout ) = fs::verwijder_bestand ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Kon bestand niet verwijderen: {}' , fout ) ;
}
}
In het gegeven voorbeeld laten we zien hoe we de inhoud van een bestand kunnen lezen met behulp van de fs::read_to_string() methode. De methode neemt het pad naar het doelbestand en retourneert de inhoud van het bestand als een tekenreeks.
We kunnen ook een nieuwe map maken met de functie fs::create_dir() en het pad naar de doelmap als parameter doorgeven.
Ten slotte kunnen we een specifiek bestand verwijderen met behulp van de functie fs::remove_file() en het doelbestand doorgeven als de parameter.
OPMERKING: De verstrekte voorbeelden zijn enkele basisvoorbeelden van het uitvoeren van bestandssysteembewerkingen op Linux met behulp van de std::fs-module. Rust biedt een uitgebreide verzameling methoden en functies die hier worden gedemonstreerd. Raadpleeg de documentatie voor meer informatie.
Procesbeheer met behulp van de OS-module
Zoals je kunt raden, biedt de OS-module submodules en functies om met processen in het systeem te werken.
Neem de volgende voorbeeldcode:
gebruik std::proces:: { Commando, Uitgang } ;fn hand ( ) {
// voer de ... uit ls commando
laten uitvoer = Command::nieuw ( 'ls' )
.arg ( '-de' )
.uitvoer ( )
.verwachten ( 'Kon opdracht niet uitvoeren' ) ;
als output.status.succes ( ) {
laten stdout = String::from_utf8_lossy ( & uitvoer.stdout ) ;
println ! ( 'Opdrachtuitvoer: \N {}' , stoer ) ;
} anders {
laten stderr = String::from_utf8_lossy ( & uitvoer.stderr ) ;
eprintln ! ( 'Opdracht mislukt: \N {}' , stderr ) ;
Uitgang ( 1 ) ;
}
}
In het gegeven voorbeeld beginnen we met het importeren van de vereiste modules. In dit geval hebben we de 'command'- en 'exit'-methoden van de submodule std::proces nodig.
Vervolgens gebruiken we de functie Command::new() om de opdracht 'ls' uit te voeren en de argumenten aan de opdracht door te geven.
Als dit lukt, zou de opdracht de directorylijst voor de huidige werkdirectory als volgt moeten retourneren:
Conclusie
We hebben onderzocht hoe de verschillende functies en methoden die door de std::os-module en submodules worden geleverd, kunnen worden gebruikt om meerdere bewerkingen uit te voeren in Linux- en Unix-achtige systemen. Onthoud dat de module std::os een uitgebreide module is die een bredere verzameling functies bevat dan degene die in deze zelfstudie worden gedemonstreerd.