Di Rust, modul std::os menyediakan abstraksi atas fungsionalitas sistem operasi. Ini memungkinkan kita untuk berinteraksi dengan sistem operasi yang mendasarinya untuk bekerja dengan variabel lingkungan, operasi sistem file, manajemen proses, dan banyak lagi.
Dalam contoh ini, kami akan membahas beberapa operasi dasar yang dapat Anda lakukan di Unix menggunakan modul Rust std::os.
Perlu diingat bahwa ini adalah modul yang ekstensif dan berisi banyak tipe dan fungsi untuk berbagai operasi terkait Unix. Oleh karena itu, harap pertimbangkan dokumentasi untuk referensi tentang proses terkait.
Rust OS di Linux
Di Linux, kita dapat mengakses fungsi dan tipe khusus Unix yang disediakan oleh modul std::os::unix, sub-modul dari modul std::os di Rust.
Modul ini adalah bagian dari pustaka standar Rust dan karenanya tidak mengharuskan Anda memasang peti atau dependensi eksternal apa pun.
Mari kita bahas beberapa API dasar dan operasi yang dapat kita lakukan pada sistem Linux dari modul ini.
Mengakses Variabel Lingkungan
Kita dapat mengakses variabel lingkungan menggunakan modul std::env. Misalnya, std::env::var(“PATH”) mengambil nilai variabel lingkungan PATH.
Perhatikan contoh program berikut ini:
gunakan std::env;gunakan std::ffi::OsString;
tangan fn ( ) {
// Akses variabel lingkungan tertentu
jika membiarkan Oke ( nilai ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , nilai ) ;
}
// Ulangi semua variabel lingkungan
untuk ( kunci, nilai ) di dalam env::wars_us ( ) {
membiarkan key_string = key.to_string_lossy ( ) ;
membiarkan nilai_string = nilai.to_string_lossy ( ) ;
println ! ( '{}:{}' , key_string, value_string ) ;
}
// Akses variabel lingkungan tertentu sebagai sebuah ` OsString `
jika membiarkan Beberapa ( nilai ) = env::var_us ( 'HOSTTYPE' ) {
// Mengubah ` OsString ` ke a ` Rangkaian ` jika diperlukan
jika membiarkan Beberapa ( nilai_str ) = nilai.to_str ( ) {
println ! ( 'HOSTTYPE={}' , nilai_str ) ;
}
}
}
Dalam contoh yang diberikan, kita mulai dengan mengimpor modul yang diperlukan. Dalam hal ini, kami tertarik pada std::env dan std::ff::OsString.
Untuk mengakses variabel lingkungan tertentu, kita dapat menggunakan fungsi env::var dan meneruskan nama nilai yang ingin kita ambil. Dalam hal ini, kita mendapatkan nilai dari variabel WAYLAND_DISPLAY.
Fungsi mengembalikan nilai variabel sebagai tipe hasil.
Kita juga dapat mengulangi semua variabel lingkungan menggunakan fungsi env::vars_os. Ini mengembalikan iterator dengan pasangan nilai kunci dari variabel lingkungan. Perlu dicatat bahwa nilai dikembalikan sebagai tipe OsString. Kami kemudian dapat mengonversinya menjadi nilai string menggunakan fungsi to_string_lossy.
Kita juga dapat mengakses variabel lingkungan tertentu menggunakan fungsi env::var_os. Ini harus mengembalikan tipe
Output yang dihasilkan adalah sebagai berikut:
WAYLAND_DISPLAY = wayland- 0HOSTTYPE =x86_64
Operasi FS Menggunakan Modul OS
Seperti yang bisa Anda tebak, modul OS menyediakan berbagai fungsi dan metode untuk melakukan operasi terkait sistem file.
Ambil program berikut yang mendemonstrasikan berbagai operasi yang dapat kita lakukan menggunakan modul std::os di Linux:
gunakan std::fs;tangan fn ( ) {
// Baca sebuah mengajukan
jika membiarkan Oke ( isi ) = fs::baca_ke_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , isi ) ;
}
// Buat direktori baru
jika membiarkan Berbuat salah ( berbuat salah ) = fs::buat_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Gagal membuat direktori: {}' , salah ) ;
}
// Hapus a mengajukan
jika membiarkan Berbuat salah ( berbuat salah ) = fs::hapus_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Gagal menghapus file: {}' , salah ) ;
}
}
Dalam contoh yang diberikan, kami mendemonstrasikan bagaimana kami dapat membaca konten file menggunakan metode fs::read_to_string() . Metode mengambil jalur ke file target dan mengembalikan konten file sebagai string.
Kita juga bisa membuat direktori baru menggunakan fungsi fs::create_dir() dan meneruskan path ke direktori target sebagai parameternya.
Terakhir, kita dapat menghapus file tertentu menggunakan fungsi fs::remove_file() dan meneruskan file target sebagai parameter.
CATATAN: Contoh yang diberikan adalah beberapa contoh dasar tentang cara melakukan operasi sistem file di Linux menggunakan modul std::fs. Rust menyediakan kumpulan lengkap metode dan fungsi yang ditunjukkan di sini. Lihat dokumentasi untuk mempelajari lebih lanjut.
Manajemen Proses Menggunakan Modul OS
Seperti yang bisa Anda tebak, modul OS menyediakan submodul dan fitur untuk bekerja dengan proses dalam sistem.
Ambil kode contoh berikut:
gunakan std::proses:: { Memerintah, KELUAR } ;tangan fn ( ) {
// menjalankan ls memerintah
membiarkan keluaran = Perintah::baru ( 'l' )
.arg ( '-itu' )
.keluaran ( )
.mengharapkan ( 'Gagal menjalankan perintah' ) ;
jika output.status.sukses ( ) {
membiarkan stdout = String::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'Keluaran perintah: \N {}' , stdout ) ;
} kalau tidak {
membiarkan stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'Perintah gagal: \N {}' , stderr ) ;
KELUAR ( 1 ) ;
}
}
Dalam contoh yang diberikan, kita mulai dengan mengimpor modul yang diperlukan. Dalam hal ini, kita memerlukan metode 'command' dan 'exit' dari std::process submodule.
Kami kemudian menggunakan fungsi Command::new() untuk menjalankan perintah 'ls' dan meneruskan argumen ke perintah.
Jika berhasil, perintah harus mengembalikan daftar direktori untuk direktori kerja saat ini sebagai berikut:
Kesimpulan
Kami menjelajahi cara menggunakan berbagai fungsi dan metode yang disediakan oleh std::os modul dan submodul untuk melakukan banyak operasi di Linux dan sistem mirip Unix. Ingatlah bahwa modul std::os adalah modul ekstensif yang berisi kumpulan fitur yang lebih luas daripada yang ditunjukkan dalam tutorial ini.