I Rust giver std::os-modulet en abstraktion over operativsystemets funktionalitet. Det giver os mulighed for at interagere med det underliggende operativsystem for at arbejde med miljøvariabler, filsystemoperationer, processtyring og mere.
I dette eksempel vil vi dække nogle grundlæggende handlinger, som du kan udføre på Unix ved hjælp af Rust std::os-modulet.
Det er godt at huske, at dette er et omfattende modul, og det indeholder mange typer og funktioner til forskellige Unix-relaterede operationer. Overvej derfor dokumentationen til reference om de tilsvarende processer.
Rust OS i Linux
I Linux kan vi få adgang til de Unix-specifikke funktioner og typer, som leveres af std::os::unix-modulet, et undermodul til std::os-modulet i Rust.
Dette modul er en del af Rust-standardbiblioteket og kræver derfor ikke, at du installerer nogen ekstern kasse eller afhængigheder.
Lad os dække nogle grundlæggende API og operationer, som vi kan udføre på et Linux-system fra dette modul.
Adgang til miljøvariabler
Vi kan få adgang til miljøvariablerne ved hjælp af std::env-modulet. For eksempel henter std::env::var(“PATH”) værdien af PATH-miljøvariablen.
Overvej følgende eksempelprogram:
brug std::env;brug std::ffi::OsString;
fn hånd ( ) {
// Få adgang til en specifik miljøvariabel
hvis lade Okay ( værdi ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , værdi ) ;
}
// Gentag over alle miljøvariabler
til ( nøgle, værdi ) i env::vars_os ( ) {
lade key_string = key.to_string_lossy ( ) ;
lade værdi_streng = værdi.til_streng_tab ( ) ;
println ! ( '{}:{}' , nøglestreng, værdistreng ) ;
}
// Få adgang til en specifik miljøvariabel som en ` OsString `
hvis lade Nogle ( værdi ) = env::var_os ( 'HOSTTYPE' ) {
// Konvertere ` OsString ` til en ` Snor ` hvis havde brug for
hvis lade Nogle ( værdi_str ) = værdi.til_str ( ) {
println ! ( 'HOSTTYPE={}' , værdi_str ) ;
}
}
}
I det givne eksempel starter vi med at importere de nødvendige moduler. I dette tilfælde er vi interesserede i std::env og std::ff::OsString.
For at få adgang til en specifik miljøvariabel kan vi bruge funktionen env::var og videregive navnet på den værdi, vi ønsker at hente. I dette tilfælde får vi værdien af variablen WAYLAND_DISPLAY.
Funktionen returnerer variablens værdi som resultattype.
Vi kan også iterere over alle miljøvariablerne ved at bruge funktionen env::vars_os. Dette returnerer en iterator med nøgleværdi-parrene af miljøvariablerne. Det er godt at bemærke, at værdierne returneres som en OsString-type. Vi kan derefter konvertere dem til strengværdier ved hjælp af to_string_lossy-funktionen.
Vi kan også få adgang til de specifikke miljøvariabler ved hjælp af funktionen env::var_os. Dette skulle returnere en
Det resulterende output er som følger:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
FS-operationer ved hjælp af OS-modulet
Som du kan gætte, giver OS-modulet forskellige funktioner og metoder til at udføre filsystem-relaterede operationer.
Tag følgende program, der viser de forskellige operationer, som vi kan udføre ved hjælp af std::os-modulet i Linux:
brug std::fs;fn hånd ( ) {
// Læs en fil
hvis lade Okay ( indhold ) = fs::læs_til_streng ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , indhold ) ;
}
// Opret en ny mappe
hvis lade Err ( fejl ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Kunne ikke oprette mappe: {}' , fejl ) ;
}
// Fjern a fil
hvis lade Err ( fejl ) = fs::fjern_fil ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Kunne ikke fjerne fil: {}' , fejl ) ;
}
}
I det givne eksempel demonstrerer vi, hvordan vi kan læse indholdet af en fil ved hjælp af fs::read_to_string() metoden. Metoden tager stien til målfilen og returnerer filindholdet som en streng.
Vi kan også oprette en ny mappe ved at bruge funktionen fs::create_dir() og sende stien til målmappen som parameter.
Endelig kan vi fjerne en specifik fil ved hjælp af fs::remove_file()-funktionen og sende målfilen som parameter.
BEMÆRK: De medfølgende eksempler er nogle grundlæggende eksempler på, hvordan man udfører filsystemoperationer på Linux ved hjælp af std::fs-modulet. Rust giver en omfattende samling af metoder og funktioner, som er demonstreret her. Se dokumentationen for at lære mere.
Processtyring ved hjælp af OS-modulet
Som du kan gætte, giver OS-modulet undermoduler og funktioner til at arbejde med processer i systemet.
Tag følgende eksempelkode:
brug std::proces:: { Kommando, Afslut } ;fn hånd ( ) {
// køre ls kommando
lade output = Kommando::ny ( 'ls' )
.arg ( '-det' )
.produktion ( )
.forventer ( 'Kunde ikke udføre kommandoen' ) ;
hvis output.status.succes ( ) {
lade stdout = String::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'Kommando output: \n {}' , standout ) ;
} andet {
lade stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'Kommando mislykkedes: \n {}' , stderr ) ;
Afslut ( 1 ) ;
}
}
I det givne eksempel starter vi med at importere de nødvendige moduler. I dette tilfælde har vi brug for 'kommando' og 'afslut' metoderne fra std::process undermodulet.
Vi bruger derefter Command::new()-funktionen til at køre kommandoen 'ls' og videregive argumenterne til kommandoen.
Hvis det lykkes, skal kommandoen returnere mappelisten for den aktuelle arbejdsmappe som følger:
Konklusion
Vi undersøgte, hvordan man bruger de forskellige funktioner og metoder, der leveres af std::os-modulet og undermodulerne til at udføre flere operationer i Linux- og Unix-lignende systemer. Husk, at std::os-modulet er et omfattende modul, der indeholder en bredere samling af funktioner end dem, der er demonstreret i denne tutorial.