A Rustban az std::os modul absztrakciót biztosít az operációs rendszer funkcióiról. Lehetővé teszi számunkra, hogy az alapul szolgáló operációs rendszerrel együttműködjünk a környezeti változókkal, a fájlrendszer-műveletekkel, a folyamatkezeléssel és még sok mással.
Ebben a példában bemutatunk néhány alapvető műveletet, amelyeket a Rust std::os modul használatával Unix rendszeren hajthat végre.
Érdemes megjegyezni, hogy ez egy kiterjedt modul, és számos típust és funkciót tartalmaz különféle Unix-szal kapcsolatos műveletekhez. Ezért kérjük, tekintse át a dokumentációt a megfelelő folyamatokra vonatkozó hivatkozásként.
Rust OS Linux alatt
Linuxban elérhetjük a Unix-specifikus funkciókat és típusokat, amelyeket az std::os::unix modul biztosít, amely a Rust std::os moduljának almodulja.
Ez a modul a Rust szabványkönyvtár része, ezért nem szükséges semmilyen külső láda vagy függőség telepítése.
Nézzünk meg néhány alapvető API-t és műveletet, amelyeket ebből a modulból Linux rendszeren végezhetünk.
A környezeti változók elérése
A környezeti változókat az std::env modul segítségével érhetjük el. Például az std::env::var(“PATH”) lekéri a PATH környezeti változó értékét.
Tekintsük a következő példaprogramot:
std::env használata;használja std::ffi::OsString;
fn kéz ( ) {
// Hozzáférés egy adott környezeti változóhoz
ha hagyja Rendben ( érték ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , érték ) ;
}
// Ismételje meg az összes környezeti változót
számára ( kulcs érték ) ban ben env::wars_us ( ) {
hagyja key_string = key.to_string_lossy ( ) ;
hagyja value_string = value.to_string_lossy ( ) ;
println ! ( '{}:{}' , kulcs_karakterlánc, érték_karakterlánc ) ;
}
// Hozzáférés egy adott környezeti változóhoz mint an ` OsString `
ha hagyja Néhány ( érték ) = env::var_us ( 'HOSTTYPE' ) {
// Alakítani ` OsString ` a ` Húr ` ha szükséges
ha hagyja Néhány ( value_str ) = value.to_str ( ) {
println ! ( 'HOSTTYPE={}' , value_str ) ;
}
}
}
Az adott példában a szükséges modulok importálásával kezdjük. Ebben az esetben az std::env és az std::ff::OsString érdekel minket.
Egy adott környezeti változó eléréséhez használhatjuk az env::var függvényt, és átadhatjuk a lekérni kívánt érték nevét. Ebben az esetben a WAYLAND_DISPLAY változó értékét kapjuk.
A függvény eredménytípusként adja vissza a változó értékét.
Az env::vars_os függvény segítségével az összes környezeti változót is át tudjuk ismételni. Ez egy iterátort ad vissza a környezeti változók kulcs-érték párjaival. Érdemes megjegyezni, hogy az értékek OsString típusként kerülnek visszaadásra. Ezután a to_string_lossy függvény segítségével karakterláncértékekké alakíthatjuk őket.
A konkrét környezeti változókat az env::var_os függvény segítségével is elérhetjük. Ennek egy
A kapott kimenet a következő:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
FS műveletek az operációs rendszer modul használatával
Ahogy sejthető, az operációs rendszer modul különféle funkciókat és módszereket biztosít a fájlrendszerrel kapcsolatos műveletek végrehajtásához.
Vegyük a következő programot, amely bemutatja a különféle műveleteket, amelyeket az std::os modul használatával hajthatunk végre Linuxban:
std::fs használata;fn kéz ( ) {
// Olvasni egy fájlt
ha hagyja Rendben ( tartalmat ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , tartalom ) ;
}
// Hozzon létre egy új könyvtárat
ha hagyja Téved ( téved ) = fs::létrehozási_könyvtár ( '/home/debian/new_dir' ) {
eprintln ! ( 'Nem sikerült létrehozni a következő könyvtárat: {}' , hiba ) ;
}
// Távolítsa el a fájlt
ha hagyja Téved ( téved ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Nem sikerült eltávolítani a következő fájlt: {}' , hiba ) ;
}
}
Az adott példában bemutatjuk, hogyan olvashatjuk ki egy fájl tartalmát az fs::read_to_string() metódussal. A metódus eléri a célfájl elérési útját, és a fájl tartalmát karakterláncként adja vissza.
Létrehozhatunk egy új könyvtárat is az fs::create_dir() függvény használatával, és paraméterként adjuk át a célkönyvtár elérési útját.
Végül eltávolíthatunk egy adott fájlt az fs::remove_file() függvény segítségével, és paraméterként átadhatjuk a célfájlt.
JEGYZET: A bemutatott példák néhány alapvető példa arra, hogyan kell végrehajtani a fájlrendszer műveleteit Linuxon az std::fs modul használatával. A Rust az itt bemutatott módszerek és funkciók átfogó gyűjteményét kínálja. További információért tekintse meg a dokumentációt.
Folyamatkezelés az operációs rendszer modul használatával
Ahogy sejthető, az operációs rendszer modul almodulokat és szolgáltatásokat biztosít a rendszer folyamataival való együttműködéshez.
Vegyük a következő példakódot:
std::process:: { Parancs, kijárat } ;fn kéz ( ) {
// futtassa a ls parancs
hagyja output = Command::new ( 'ls' )
.arg ( '-a' )
.Kimenet ( )
.elvárni ( 'Nem sikerült végrehajtani a parancsot' ) ;
ha kimenet.állapot.siker ( ) {
hagyja stdout = String::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'Parancs kimenet: \n {}' , stdout ) ;
} más {
hagyja stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'A parancs nem sikerült: \n {}' , stderr ) ;
kijárat ( 1 ) ;
}
}
Az adott példában a szükséges modulok importálásával kezdjük. Ebben az esetben szükségünk van a „command” és „exit” metódusokra az std::process almodulból.
Ezután a Command::new() függvény segítségével futtatjuk az „ls” parancsot, és átadjuk az argumentumokat a parancsnak.
Ha sikeres, a parancsnak vissza kell adnia az aktuális munkakönyvtár könyvtárlistáját a következőképpen:
Következtetés
Megvizsgáltuk, hogyan használhatjuk az std::os modul és az almodulok által biztosított különféle funkciókat és módszereket több művelet végrehajtására Linux és Unix-szerű rendszerekben. Ne feledje, hogy az std::os modul egy kiterjedt modul, amely a jelen oktatóanyagban bemutatottaknál szélesebb szolgáltatásgyűjteményt tartalmaz.