Dalam Rust, modul std::os menyediakan abstraksi ke atas fungsi sistem pengendalian. Ia membolehkan kami berinteraksi dengan sistem pengendalian asas untuk bekerja dengan pembolehubah persekitaran, operasi sistem fail, pengurusan proses dan banyak lagi.
Dalam contoh ini, kami akan merangkumi beberapa operasi asas yang boleh anda lakukan pada Unix menggunakan modul Rust std::os.
Adalah baik untuk diingat bahawa ini adalah modul yang luas dan ia mengandungi banyak jenis dan fungsi untuk pelbagai operasi berkaitan Unix. Oleh itu, sila pertimbangkan dokumentasi untuk rujukan mengenai proses yang sepadan.
Rust OS dalam Linux
Di Linux, kita boleh mengakses fungsi dan jenis khusus Unix yang disediakan oleh modul std::os::unix, sub-modul modul std::os dalam Rust.
Modul ini adalah sebahagian daripada pustaka standard Rust dan oleh itu tidak memerlukan anda memasang sebarang peti luaran atau kebergantungan.
Mari kita meliputi beberapa API asas dan operasi yang boleh kita jalankan pada sistem Linux daripada modul ini.
Mengakses Pembolehubah Persekitaran
Kita boleh mengakses pembolehubah persekitaran menggunakan modul std::env. Contohnya, std::env::var('PATH') mendapatkan semula nilai pembolehubah persekitaran PATH.
Pertimbangkan contoh program berikut:
gunakan std::env;gunakan std::ffi::OsString;
tangan fn ( ) {
// Akses pembolehubah persekitaran tertentu
jika biarkan Okey ( nilai ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , nilai ) ;
}
// Lelaran ke atas semua pembolehubah persekitaran
untuk ( kunci, nilai ) dalam env::wars_us ( ) {
biarkan key_string = key.to_string_lossy ( ) ;
biarkan value_string = value.to_string_lossy ( ) ;
println ! ( '{}:{}' , rentetan_kunci, rentetan_nilai ) ;
}
// Akses pembolehubah persekitaran tertentu sebagai an ` OsString `
jika biarkan Beberapa ( nilai ) = env::var_us ( 'HOSTTYPE' ) {
// Tukar ` OsString ` kepada a ` Tali ` jika diperlukan
jika biarkan Beberapa ( value_str ) = value.to_str ( ) {
println ! ( 'HOSTTYPE={}' , value_str ) ;
}
}
}
Dalam contoh yang diberikan, kita mulakan dengan mengimport modul yang diperlukan. Dalam kes ini, kami berminat dengan std::env dan std::ff::OsString.
Untuk mengakses pembolehubah persekitaran tertentu, kita boleh menggunakan fungsi env::var dan lulus nama nilai yang ingin kita ambil. Dalam kes ini, kita mendapat nilai pembolehubah WAYLAND_DISPLAY.
Fungsi mengembalikan nilai pembolehubah sebagai jenis hasil.
Kita juga boleh mengulangi semua pembolehubah persekitaran menggunakan fungsi env::vars_os. Ini mengembalikan iterator dengan pasangan nilai kunci pembolehubah persekitaran. Adalah baik untuk ambil perhatian bahawa nilai dikembalikan sebagai jenis OsString. Kami kemudiannya boleh menukarnya kepada nilai rentetan menggunakan fungsi to_string_lossy.
Kami juga boleh mengakses pembolehubah persekitaran tertentu menggunakan fungsi env::var_os. Ini sepatutnya mengembalikan jenis
Output yang terhasil adalah seperti berikut:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
Operasi FS Menggunakan Modul OS
Seperti yang anda boleh teka, modul OS menyediakan pelbagai fungsi dan kaedah untuk melaksanakan operasi berkaitan sistem fail.
Ambil program berikut yang menunjukkan pelbagai operasi yang boleh kami lakukan menggunakan modul std::os dalam Linux:
gunakan std::fs;tangan fn ( ) {
// Baca a fail
jika biarkan Okey ( kandungan ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , kandungan ) ;
}
// Buat direktori baharu
jika biarkan Err ( silap ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Gagal mencipta direktori: {}' , silap ) ;
}
// Keluarkan a fail
jika biarkan Err ( silap ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Gagal mengalih keluar fail: {}' , silap ) ;
}
}
Dalam contoh yang diberikan, kami menunjukkan cara kami boleh membaca kandungan fail menggunakan kaedah fs::read_to_string(). Kaedah mengambil laluan ke fail sasaran dan mengembalikan kandungan fail sebagai rentetan.
Kita juga boleh mencipta direktori baharu menggunakan fungsi fs::create_dir() dan menghantar laluan ke direktori sasaran sebagai parameter.
Akhir sekali, kita boleh mengalih keluar fail tertentu menggunakan fungsi fs::remove_file() dan lulus fail sasaran sebagai parameter.
CATATAN: Contoh yang diberikan ialah beberapa contoh asas tentang cara melaksanakan operasi sistem fail pada Linux menggunakan modul std::fs. Rust menyediakan koleksi kaedah dan fungsi yang komprehensif yang ditunjukkan di sini. Rujuk dokumentasi untuk mengetahui lebih lanjut.
Pengurusan Proses Menggunakan Modul OS
Seperti yang anda boleh meneka, modul OS menyediakan submodul dan ciri untuk berfungsi dengan proses dalam sistem.
Ambil contoh kod berikut:
gunakan std::process:: { Perintah, keluar } ;tangan fn ( ) {
// menjalankan ls perintah
biarkan output = Perintah::baru ( 'ls' )
.arg ( '-yang' )
.pengeluaran ( )
.harapkan ( 'Gagal melaksanakan arahan' ) ;
jika keluaran.status.kejayaan ( ) {
biarkan stdout = String::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'Keluaran arahan: \n {}' , stdout ) ;
} lain {
biarkan stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'Arahan gagal: \n {}' , stderr ) ;
keluar ( 1 ) ;
}
}
Dalam contoh yang diberikan, kita mulakan dengan mengimport modul yang diperlukan. Dalam kes ini, kita memerlukan kaedah 'perintah' dan 'keluar' daripada submodul proses std::.
Kami kemudian menggunakan fungsi Command::new() untuk menjalankan perintah 'ls' dan menyampaikan argumen kepada arahan.
Jika berjaya, arahan harus mengembalikan senarai direktori untuk direktori kerja semasa seperti berikut:
Kesimpulan
Kami meneroka cara menggunakan pelbagai fungsi dan kaedah yang disediakan oleh modul dan submodul std::os untuk melaksanakan berbilang operasi dalam sistem seperti Linux dan Unix. Ingat bahawa modul std::os ialah modul yang luas yang mengandungi koleksi ciri yang lebih luas daripada yang ditunjukkan dalam tutorial ini.