W Rust moduł std::os zapewnia abstrakcję funkcjonalności systemu operacyjnego. Pozwala nam na interakcję z bazowym systemem operacyjnym w celu pracy ze zmiennymi środowiskowymi, operacjami systemu plików, zarządzaniem procesami i nie tylko.
W tym przykładzie omówimy podstawowe operacje, które można wykonać w systemie Unix przy użyciu modułu std::os Rust.
Warto pamiętać, że jest to moduł rozbudowany i zawiera wiele typów i funkcji dla różnych operacji związanych z Unixem. Dlatego prosimy o zapoznanie się z dokumentacją dotyczącą odpowiednich procesów.
Rdzawy system operacyjny w systemie Linux
W Linuksie możemy uzyskać dostęp do funkcji i typów specyficznych dla systemu Unix, które są dostarczane przez moduł std::os::unix, podmoduł modułu std::os w Rust.
Ten moduł jest częścią standardowej biblioteki Rust i dlatego nie wymaga instalowania żadnych zewnętrznych skrzynek ani zależności.
Omówimy kilka podstawowych interfejsów API i operacji, które możemy wykonać w systemie Linux z tego modułu.
Dostęp do zmiennych środowiskowych
Możemy uzyskać dostęp do zmiennych środowiskowych za pomocą modułu std::env. Na przykład std::env::var('PATH') pobiera wartość zmiennej środowiskowej PATH.
Rozważ następujący przykładowy program:
użyj std::env;użyj std::ffi::OsString;
fn ręka ( ) {
// Uzyskaj dostęp do określonej zmiennej środowiskowej
Jeśli pozwalać OK ( wartość ) = env::var ( „WAYLAND_DISPLAY” ) {
println ! ( 'WAYLAND_DISPLAY={}' , wartość ) ;
}
// Iteruj po wszystkich zmiennych środowiskowych
Do ( kluczowa wartość ) W env::wars_us ( ) {
pozwalać ciąg_kluczy = klucz.do_ciągu_stratnego ( ) ;
pozwalać ciąg_wartości = wartość.do_ciągu_strat ( ) ;
println ! ( '{}:{}' , ciąg_kluczy, ciąg_wartości ) ;
}
// Uzyskaj dostęp do określonej zmiennej środowiskowej Jak jakiś ` OsString `
Jeśli pozwalać Niektóre ( wartość ) = env::var_us ( „TYP HOSTA” ) {
// Konwertować ` OsString ` do ` Strunowy ` Jeśli potrzebne
Jeśli pozwalać Niektóre ( wartość_str ) = wartość.do_str ( ) {
println ! ( 'TYPHOSTA={}' , wartość_str ) ;
}
}
}
W podanym przykładzie zaczynamy od zaimportowania niezbędnych modułów. W tym przypadku interesują nas std::env i std::ff::OsString.
Aby uzyskać dostęp do określonej zmiennej środowiskowej, możemy użyć funkcji env::var i przekazać nazwę wartości, którą chcemy pobrać. W tym przypadku otrzymujemy wartość zmiennej WAYLAND_DISPLAY.
Funkcja zwraca wartość zmiennej jako typ wyniku.
Możemy również iterować po wszystkich zmiennych środowiskowych za pomocą funkcji env::vars_os. To zwraca iterator z parami klucz-wartość zmiennych środowiskowych. Warto zauważyć, że wartości są zwracane jako typ OsString. Następnie możemy przekonwertować je na wartości łańcuchowe za pomocą funkcji to_string_lossy.
Możemy również uzyskać dostęp do określonych zmiennych środowiskowych za pomocą funkcji env::var_os. Powinno to zwrócić typ
Wynikowy wynik jest następujący:
WAYLAND_DISPLAY =wayland- 0TYPHOSTA =x86_64
Operacje FS przy użyciu modułu systemu operacyjnego
Jak można się domyślić, moduł OS udostępnia różne funkcje i metody wykonywania operacji związanych z systemem plików.
Weźmy następujący program, który demonstruje różne operacje, które możemy wykonać za pomocą modułu std::os w systemie Linux:
użyj std::fs;fn ręka ( ) {
// Czytać plik
Jeśli pozwalać OK ( zawartość ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , zawartość ) ;
}
// Utwórz nowy katalog
Jeśli pozwalać Błądzić ( błądzić ) = fs::create_dir ( '/home/debian/nowy_katalog' ) {
eprintln ! ( „Nie udało się utworzyć katalogu: {}” , błąd ) ;
}
// Usuń plik
Jeśli pozwalać Błądzić ( błądzić ) = fs::usuń_plik ( '/home/debian/remove_me.txt' ) {
eprintln ! ( „Nie udało się usunąć pliku: {}” , błąd ) ;
}
}
W podanym przykładzie pokazujemy, jak możemy odczytać zawartość pliku za pomocą metody fs::read_to_string() . Metoda pobiera ścieżkę do pliku docelowego i zwraca zawartość pliku jako ciąg znaków.
Możemy również utworzyć nowy katalog za pomocą funkcji fs::create_dir() i przekazując jako parametr ścieżkę do katalogu docelowego.
Na koniec możemy usunąć określony plik za pomocą funkcji fs::remove_file() i przekazać plik docelowy jako parametr.
NOTATKA: Podane przykłady to podstawowe przykłady wykonywania operacji na systemie plików w systemie Linux przy użyciu modułu std::fs. Rust zapewnia obszerny zbiór metod i funkcji, które są tutaj zademonstrowane. Zapoznaj się z dokumentacją, aby dowiedzieć się więcej.
Zarządzanie procesami za pomocą modułu systemu operacyjnego
Jak można się domyślić, moduł systemu operacyjnego udostępnia podmoduły i funkcje do pracy z procesami w systemie.
Weź następujący przykładowy kod:
użyj std::proces:: { Komenda, Wyjście } ;fn ręka ( ) {
// uruchomić ls Komenda
pozwalać wyjście = Polecenie::nowy ( „ls” )
.arg ( „-ten” )
.wyjście ( )
.oczekiwać ( „Nie udało się wykonać polecenia” ) ;
Jeśli stan.wyjścia.sukces ( ) {
pozwalać stdout = String::from_utf8_lossy ( & wyjście.stdout ) ;
println ! ( „Wyjście polecenia: \N {}' , standardowe wyjście ) ;
} w przeciwnym razie {
pozwalać stderr = String::from_utf8_lossy ( & wyjście.stderr ) ;
eprintln ! ( „Polecenie nie powiodło się: \N {}' , stderr ) ;
Wyjście ( 1 ) ;
}
}
W podanym przykładzie zaczynamy od zaimportowania wymaganych modułów. W tym przypadku potrzebujemy metod „command” i „exit” z podmodułu std::process.
Następnie używamy funkcji Command::new() do uruchomienia polecenia „ls” i przekazania argumentów do polecenia.
Jeśli się powiedzie, polecenie powinno zwrócić listę katalogów dla bieżącego katalogu roboczego w następujący sposób:
Wniosek
Zbadaliśmy, jak używać różnych funkcji i metod dostarczanych przez moduł std::os i moduły podrzędne do wykonywania wielu operacji w systemach Linux i systemach typu Unix. Pamiętaj, że moduł std::os jest rozbudowanym modułem, który zawiera szerszy zbiór funkcji niż te, które zostały zademonstrowane w tym samouczku.