I Rust ger std::os-modulen en abstraktion över operativsystemets funktionalitet. Det tillåter oss att interagera med det underliggande operativsystemet för att arbeta med miljövariabler, filsystemoperationer, processhantering och mer.
I det här exemplet kommer vi att täcka några grundläggande operationer som du kan utföra på Unix med Rust std::os-modulen.
Det är bra att komma ihåg att detta är en omfattande modul och den innehåller många typer och funktioner för olika Unix-relaterade operationer. Beakta därför dokumentationen för referens om motsvarande processer.
Rust OS i Linux
I Linux kan vi komma åt de Unix-specifika funktionerna och typerna som tillhandahålls av modulen std::os::unix, en undermodul till modulen std::os i Rust.
Denna modul är en del av Rust-standardbiblioteket och kräver därför inte att du installerar någon extern låda eller beroenden.
Låt oss täcka några grundläggande API och operationer som vi kan utföra på ett Linux-system från denna modul.
Åtkomst till miljövariabler
Vi kan komma åt miljövariablerna med modulen std::env. Till exempel, std::env::var(“PATH”) hämtar värdet på miljövariabeln PATH.
Tänk på följande exempelprogram:
använd std::env;använd std::ffi::OsString;
fn hand ( ) {
// Få tillgång till en specifik miljövariabel
om låta Ok ( värde ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , värde ) ;
}
// Iterera över alla miljövariabler
för ( nyckelvärde ) i env::wars_us ( ) {
låta key_string = key.to_string_lossy ( ) ;
låta värde_sträng = värde.till_sträng_förlust ( ) ;
println ! ( '{}:{}' , nyckelsträng, värdesträng ) ;
}
// Få tillgång till en specifik miljövariabel som en ` OsString `
om låta Några ( värde ) = env::var_us ( 'HOSTTYPE' ) {
// Konvertera ` OsString ` till a ` Sträng ` om behövs
om låta Några ( värde_str ) = värde.till_str ( ) {
println ! ( 'HOSTTYPE={}' , värde_str ) ;
}
}
}
I det givna exemplet börjar vi med att importera de nödvändiga modulerna. I det här fallet är vi intresserade av std::env och std::ff::OsString.
För att komma åt en specifik miljövariabel kan vi använda funktionen env::var och skicka namnet på värdet som vi vill hämta. I det här fallet får vi värdet på variabeln WAYLAND_DISPLAY.
Funktionen returnerar variabelns värde som en resultattyp.
Vi kan också iterera över alla miljövariabler med funktionen env::vars_os. Detta returnerar en iterator med nyckel-värdeparen för miljövariablerna. Det är bra att notera att värdena returneras som en OsString-typ. Vi kan sedan konvertera dem till strängvärden med funktionen to_string_lossy.
Vi kan också komma åt de specifika miljövariablerna med funktionen env::var_os. Detta bör returnera en
Resultatet är som följer:
WAYLAND_DISPLAY =wayland- 0VÄRDTYP =x86_64
FS-operationer med OS-modulen
Som du kan gissa ger OS-modulen olika funktioner och metoder för att utföra filsystemrelaterade operationer.
Ta följande program som visar de olika operationerna som vi kan utföra med std::os-modulen i Linux:
använd std::fs;fn hand ( ) {
// Läs en fil
om låta Ok ( innehåll ) = fs::läs_till_sträng ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , innehåll ) ;
}
// Skapa en ny katalog
om låta Fela ( fela ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Det gick inte att skapa katalog: {}' , fel ) ;
}
// Ta bort a fil
om låta Fela ( fela ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Det gick inte att ta bort filen: {}' , fel ) ;
}
}
I det givna exemplet visar vi hur vi kan läsa innehållet i en fil med metoden fs::read_to_string(). Metoden tar sökvägen till målfilen och returnerar filinnehållet som en sträng.
Vi kan också skapa en ny katalog med funktionen fs::create_dir() och skicka sökvägen till målkatalogen som parameter.
Slutligen kan vi ta bort en specifik fil med funktionen fs::remove_file() och skicka målfilen som parameter.
NOTERA: De medföljande exemplen är några grundläggande exempel på hur man utför filsystemoperationer på Linux med std::fs-modulen. Rust tillhandahåller en omfattande samling av metoder och funktioner som visas här. Se dokumentationen för mer information.
Processhantering med hjälp av OS-modulen
Som du kan gissa ger OS-modulen undermoduler och funktioner för att arbeta med processer i systemet.
Ta följande exempelkod:
använd std::process:: { Kommando, utgång } ;fn hand ( ) {
// springa det ls kommando
låta output = Kommando::ny ( 'ls' )
.arg ( '-de' )
.produktion ( )
.förvänta ( 'Det gick inte att utföra kommandot' ) ;
om output.status.framgång ( ) {
låta stdout = String::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'Kommandoutgång: \n {}' , stdout ) ;
} annan {
låta stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'Kommandot misslyckades: \n {}' , stderr ) ;
utgång ( 1 ) ;
}
}
I det givna exemplet börjar vi med att importera de nödvändiga modulerna. I det här fallet behöver vi metoderna 'kommando' och 'avsluta' från undermodulen std::process.
Vi använder sedan Command::new()-funktionen för att köra kommandot 'ls' och skicka argumenten till kommandot.
Om det lyckas bör kommandot returnera kataloglistan för den aktuella arbetskatalogen enligt följande:
Slutsats
Vi utforskade hur man använder de olika funktionerna och metoderna som tillhandahålls av std::os-modulen och undermodulerna för att utföra flera operationer i Linux- och Unix-liknande system. Kom ihåg att std::os-modulen är en omfattande modul som innehåller en bredare samling funktioner än de som visas i denna handledning.