I Rust gir std::os-modulen en abstraksjon over operativsystemets funksjonalitet. Det lar oss samhandle med det underliggende operativsystemet for å jobbe med miljøvariabler, filsystemoperasjoner, prosessbehandling og mer.
I dette eksemplet vil vi dekke noen grunnleggende operasjoner som du kan utføre på Unix ved å bruke Rust std::os-modulen.
Det er greit å huske at dette er en omfattende modul og den inneholder mange typer og funksjoner for ulike Unix-relaterte operasjoner. Se derfor dokumentasjonen for referanse om de tilsvarende prosessene.
Rust OS i Linux
I Linux kan vi få tilgang til de Unix-spesifikke funksjonene og typene som leveres av std::os::unix-modulen, en undermodul av std::os-modulen i Rust.
Denne modulen er en del av Rust-standardbiblioteket og krever derfor ikke at du installerer noen ekstern kasse eller avhengigheter.
La oss dekke noen grunnleggende API og operasjoner som vi kan utføre på et Linux-system fra denne modulen.
Få tilgang til miljøvariablene
Vi kan få tilgang til miljøvariablene ved å bruke std::env-modulen. For eksempel henter std::env::var(“PATH”) verdien av PATH-miljøvariabelen.
Tenk på følgende eksempelprogram:
bruk std::env;bruk std::ffi::OsString;
fn hånd ( ) {
// Få tilgang til en spesifikk miljøvariabel
hvis la Ok ( verdi ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , verdi ) ;
}
// Iterer over alle miljøvariabler
til ( nøkkel, verdi ) i env::wars_us ( ) {
la key_string = key.to_string_lossy ( ) ;
la verdi_streng = verdi.til_streng_tap ( ) ;
println ! ( '{}:{}' , nøkkelstreng, verdistreng ) ;
}
// Få tilgang til en spesifikk miljøvariabel som an ` OsString `
hvis la Noen ( verdi ) = env::var_us ( 'HOSTTYPE' ) {
// Konvertere ` OsString ` til en ` String ` hvis behov for
hvis la Noen ( verdi_str ) = verdi.til_str ( ) {
println ! ( 'HOSTTYPE={}' , verdi_str ) ;
}
}
}
I det gitte eksemplet starter vi med å importere de nødvendige modulene. I dette tilfellet er vi interessert i std::env og std::ff::OsString.
For å få tilgang til en spesifikk miljøvariabel kan vi bruke funksjonen env::var og sende navnet på verdien vi ønsker å hente. I dette tilfellet får vi verdien av variabelen WAYLAND_DISPLAY.
Funksjonen returnerer variabelens verdi som en resultattype.
Vi kan også iterere over alle miljøvariablene ved å bruke funksjonen env::vars_os. Dette returnerer en iterator med nøkkelverdi-parene til miljøvariablene. Det er greit å merke seg at verdiene returneres som en OsString-type. Vi kan deretter konvertere dem til strengverdier ved å bruke to_string_lossy-funksjonen.
Vi kan også få tilgang til de spesifikke miljøvariablene ved å bruke funksjonen env::var_os. Dette skal returnere en
Den resulterende utgangen er som følger:
WAYLAND_DISPLAY =veiland- 0HOSTTYPE =x86_64
FS-operasjoner ved hjelp av OS-modulen
Som du kan gjette, gir OS-modulen forskjellige funksjoner og metoder for å utføre filsystemrelaterte operasjoner.
Ta følgende program som viser de ulike operasjonene vi kan utføre ved å bruke std::os-modulen i Linux:
bruk std::fs;fn hånd ( ) {
// Lese en fil
hvis la Ok ( innhold ) = fs::les_til_streng ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , innhold ) ;
}
// Opprett en ny katalog
hvis la Err ( feil ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Kunne ikke opprette katalog: {}' , feil ) ;
}
// Fjern a fil
hvis la Err ( feil ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Kunne ikke fjerne filen: {}' , feil ) ;
}
}
I det gitte eksemplet viser vi hvordan vi kan lese innholdet i en fil ved å bruke fs::read_to_string()-metoden. Metoden tar banen til målfilen og returnerer filinnholdet som en streng.
Vi kan også opprette en ny katalog ved å bruke funksjonen fs::create_dir() og sende stien til målkatalogen som parameter.
Til slutt kan vi fjerne en spesifikk fil ved å bruke funksjonen fs::remove_file() og sende målfilen som parameter.
MERK: De medfølgende eksemplene er noen grunnleggende eksempler på hvordan du utfører filsystemoperasjoner på Linux ved å bruke std::fs-modulen. Rust gir en omfattende samling av metoder og funksjoner som er demonstrert her. Se dokumentasjonen for å lære mer.
Prosessbehandling ved hjelp av OS-modulen
Som du kan gjette, gir OS-modulen undermoduler og funksjoner for å jobbe med prosesser i systemet.
Ta følgende eksempelkode:
bruk std::process:: { Kommando, exit } ;fn hånd ( ) {
// kjøre ls kommando
la output = Kommando::ny ( 'ls' )
.arg ( '-de' )
.produksjon ( )
.forvent ( 'Kunne ikke utføre kommandoen' ) ;
hvis output.status.suksess ( ) {
la stdout = String::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'Kommandoutgang: \n {}' , standout ) ;
} ellers {
la stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'Kommando mislyktes: \n {}' , stderr ) ;
exit ( 1 ) ;
}
}
I det gitte eksemplet starter vi med å importere de nødvendige modulene. I dette tilfellet trenger vi metodene 'kommando' og 'avslutt' fra undermodulen std::process.
Vi bruker deretter Command::new()-funksjonen for å kjøre 'ls'-kommandoen og sende argumentene til kommandoen.
Hvis den lykkes, skal kommandoen returnere katalogoppføringen for gjeldende arbeidskatalog som følger:
Konklusjon
Vi utforsket hvordan du bruker de ulike funksjonene og metodene som tilbys av std::os-modulen og undermodulene for å utføre flere operasjoner i Linux- og Unix-lignende systemer. Husk at std::os-modulen er en omfattende modul som inneholder en bredere samling funksjoner enn de som er demonstrert i denne opplæringen.