V Rustu poskytuje modul std::os abstrakci nad funkčností operačního systému. Umožňuje nám komunikovat se základním operačním systémem a pracovat s proměnnými prostředí, operacemi souborového systému, správou procesů a dalšími.
V tomto příkladu pokryjeme některé základní operace, které můžete provádět na Unixu pomocí modulu Rust std::os.
Je dobré si zapamatovat, že se jedná o rozsáhlý modul a obsahuje mnoho typů a funkcí pro různé operace související s Unixem. Zvažte proto prosím dokumentaci pro referenci o odpovídajících procesech.
Rust OS v Linuxu
V Linuxu máme přístup k funkcím a typům specifickým pro Unix, které poskytuje modul std::os::unix, podmodul modulu std::os v Rustu.
Tento modul je součástí standardní knihovny Rust, a proto nevyžaduje instalaci žádné externí bedny nebo závislostí.
Podívejme se na některé základní API a operace, které můžeme z tohoto modulu provádět na systému Linux.
Přístup k proměnným prostředí
K proměnným prostředí můžeme přistupovat pomocí modulu std::env. Například std::env::var(“PATH”) načte hodnotu proměnné prostředí PATH.
Zvažte následující příklad programu:
použít std::env;použijte std::ffi::OsString;
fn ruka ( ) {
// Přístup ke konkrétní proměnné prostředí
-li nechat OK ( hodnota ) = env::var ( „WAYLAND_DISPLAY“ ) {
println ! ( 'WAYLAND_DISPLAY={}' , hodnota ) ;
}
// Iterujte přes všechny proměnné prostředí
pro ( klíč, hodnota ) v env::wars_us ( ) {
nechat key_string = key.to_string_lossy ( ) ;
nechat value_string = value.to_string_lossy ( ) ;
println ! ( '{}:{}' , klíčový_řetězec, hodnotový_řetězec ) ;
}
// Přístup ke konkrétní proměnné prostředí tak jako an ' OsString '
-li nechat Nějaký ( hodnota ) = env::var_us ( 'HOSTTYPE' ) {
// Konvertovat ' OsString ' do a ' Tětiva ' -li potřeboval
-li nechat Nějaký ( value_str ) = hodnota.k_str ( ) {
println ! ( 'HOSTTYPE={}' , hodnota_str ) ;
}
}
}
V uvedeném příkladu začneme importem potřebných modulů. V tomto případě nás zajímá std::env a std::ff::OsString.
Pro přístup ke konkrétní proměnné prostředí můžeme použít funkci env::var a předat název hodnoty, kterou chceme načíst. V tomto případě dostaneme hodnotu proměnné WAYLAND_DISPLAY.
Funkce vrací hodnotu proměnné jako typ výsledku.
Můžeme také iterovat všechny proměnné prostředí pomocí funkce env::vars_os. To vrátí iterátor s páry klíč-hodnota proměnných prostředí. Je dobré si uvědomit, že hodnoty jsou vráceny jako typ OsString. Ty pak můžeme převést na řetězcové hodnoty pomocí funkce to_string_lossy.
Ke specifickým proměnným prostředí můžeme také přistupovat pomocí funkce env::var_os. To by mělo vrátit typ
Výsledný výstup je následující:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
Operace FS pomocí modulu OS
Jak můžete hádat, modul OS poskytuje různé funkce a metody k provádění operací souvisejících se souborovým systémem.
Vezměte si následující program, který demonstruje různé operace, které můžeme provádět pomocí modulu std::os v Linuxu:
použijte std::fs;fn ruka ( ) {
// Číst soubor
-li nechat OK ( obsah ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , obsah ) ;
}
// Vytvořte nový adresář
-li nechat Chybovat ( chybovat ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Nepodařilo se vytvořit adresář: {}' , chyba ) ;
}
// Odebrat a soubor
-li nechat Chybovat ( chybovat ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Nepodařilo se odstranit soubor: {}' , chyba ) ;
}
}
Na uvedeném příkladu demonstrujeme, jak můžeme číst obsah souboru pomocí metody fs::read_to_string(). Metoda vezme cestu k cílovému souboru a vrátí obsah souboru jako řetězec.
Můžeme také vytvořit nový adresář pomocí funkce fs::create_dir() a jako parametr předat cestu k cílovému adresáři.
Nakonec můžeme odstranit konkrétní soubor pomocí funkce fs::remove_file() a předat cílový soubor jako parametr.
POZNÁMKA: Uvedené příklady jsou některé základní příklady toho, jak provádět operace souborového systému v Linuxu pomocí modulu std::fs. Rust poskytuje komplexní soubor metod a funkcí, které jsou zde demonstrovány. Další informace naleznete v dokumentaci.
Správa procesů pomocí modulu OS
Jak můžete hádat, modul OS poskytuje submoduly a funkce pro práci s procesy v systému.
Vezměte si následující příklad kódu:
použít std::process:: { Příkaz, výstup } ;fn ruka ( ) {
// spustit ls příkaz
nechat output = Příkaz::new ( 'ls' )
.arg ( '-the' )
.výstup ( )
.očekávat ( 'Nepodařilo se provést příkaz' ) ;
-li výstup.stav.úspěch ( ) {
nechat stdout = Řetězec::from_utf8_lossy ( & výstup.stdout ) ;
println ! ( 'Výstup příkazu: \n {} , stdout ) ;
} jiný {
nechat stderr = Řetězec::from_utf8_lossy ( & výstup.stderr ) ;
eprintln ! ( 'Příkaz selhal: \n {} , stderr ) ;
výstup ( 1 ) ;
}
}
V uvedeném příkladu začneme importem požadovaných modulů. V tomto případě potřebujeme metody „command“ a „exit“ ze submodulu std::process.
Poté pomocí funkce Command::new() spustíme příkaz „ls“ a předáme argumenty příkazu.
Pokud bude úspěšný, měl by příkaz vrátit výpis adresáře pro aktuální pracovní adresář následovně:
Závěr
Zkoumali jsme, jak používat různé funkce a metody, které poskytuje modul std::os a submoduly k provádění více operací v systémech Linux a Unix. Pamatujte, že modul std::os je rozsáhlý modul, který obsahuje širší sbírku funkcí než ty, které jsou uvedeny v tomto tutoriálu.