Sa Rust, ang std::os module ay nagbibigay ng abstraction sa functionality ng operating system. Nagbibigay-daan ito sa amin na makipag-ugnayan sa pinagbabatayan na operating system upang gumana sa mga variable ng kapaligiran, mga pagpapatakbo ng file system, pamamahala ng proseso, at higit pa.
Sa halimbawang ito, tatalakayin namin ang ilang pangunahing operasyon na maaari mong gawin sa Unix gamit ang Rust std::os module.
Magandang tandaan na ito ay isang malawak na module at naglalaman ito ng maraming uri at function para sa iba't ibang mga operasyong nauugnay sa Unix. Samakatuwid, mangyaring isaalang-alang ang dokumentasyon para sa sanggunian sa mga kaukulang proseso.
Rust OS sa Linux
Sa Linux, maa-access natin ang mga function at uri na partikular sa Unix na ibinibigay ng std::os::unix module, isang sub-module ng std::os module sa Rust.
Ang module na ito ay bahagi ng Rust standard library at samakatuwid ay hindi mo hinihiling na mag-install ng anumang panlabas na crate o dependencies.
Sakupin natin ang ilang pangunahing API at mga operasyon na maaari nating isagawa sa isang Linux system mula sa module na ito.
Pag-access sa Mga Variable ng Kapaligiran
Maa-access natin ang mga variable ng kapaligiran gamit ang std::env module. Halimbawa, kinukuha ng std::env::var('PATH') ang halaga ng variable na kapaligiran ng PATH.
Isaalang-alang ang sumusunod na halimbawa ng programa:
gumamit ng std::env;gumamit ng std::ffi::OsString;
fn kamay ( ) {
// I-access ang isang partikular na variable ng kapaligiran
kung hayaan Ok ( halaga ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , halaga ) ;
}
// Ulitin sa lahat ng mga variable ng kapaligiran
para sa ( susi, halaga ) sa env::wars_us ( ) {
hayaan key_string = key.to_string_lossy ( ) ;
hayaan value_string = value.to_string_lossy ( ) ;
println ! ( '{}:{}' , key_string, value_string ) ;
}
// I-access ang isang partikular na variable ng kapaligiran bilang isang ` OsString `
kung hayaan Ang ilan ( halaga ) = env::var_us ( 'HOSTTYPE' ) {
// Magbalik-loob ` OsString ` sa a ` String ` kung kailangan
kung hayaan Ang ilan ( value_str ) = value.to_str ( ) {
println ! ( 'HOSTTYPE={}' , value_str ) ;
}
}
}
Sa ibinigay na halimbawa, magsisimula kami sa pamamagitan ng pag-import ng mga kinakailangang module. Sa kasong ito, interesado kami sa std::env at sa std::ff::OsString.
Upang ma-access ang isang partikular na variable ng kapaligiran, maaari naming gamitin ang env::var function at ipasa ang pangalan ng value na gusto naming kunin. Sa kasong ito, nakukuha namin ang halaga ng variable na WAYLAND_DISPLAY.
Ibinabalik ng function ang value ng variable bilang uri ng resulta.
Maaari din nating ulitin ang lahat ng mga variable ng kapaligiran gamit ang env::vars_os function. Nagbabalik ito ng isang iterator na may mga pares ng key-value ng mga variable ng kapaligiran. Magandang tandaan na ang mga halaga ay ibinalik bilang isang uri ng OsString. Pagkatapos ay maaari nating i-convert ang mga ito sa mga string value gamit ang to_string_lossy function.
Maa-access din natin ang mga partikular na variable ng kapaligiran gamit ang env::var_os function. Dapat itong magbalik ng uri ng
Ang resultang output ay ang mga sumusunod:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
FS Operations Gamit ang OS Module
Tulad ng maaari mong hulaan, ang OS module ay nagbibigay ng iba't ibang mga function at pamamaraan upang maisagawa ang mga operasyong nauugnay sa filesystem.
Kunin ang sumusunod na programa na nagpapakita ng iba't ibang mga operasyon na maaari naming gawin gamit ang std::os module sa Linux:
gumamit ng std::fs;fn kamay ( ) {
// Magbasa ng file
kung hayaan Ok ( nilalaman ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , mga nilalaman ) ;
}
// Lumikha ng bagong direktoryo
kung hayaan Err ( magkamali ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Nabigong lumikha ng direktoryo: {}' , mali ) ;
}
// Alisin a file
kung hayaan Err ( magkamali ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Nabigong alisin ang file: {}' , mali ) ;
}
}
Sa ibinigay na halimbawa, ipinapakita namin kung paano namin mababasa ang mga nilalaman ng isang file gamit ang fs::read_to_string() na pamamaraan. Dinadala ng pamamaraan ang landas patungo sa target na file at ibinabalik ang mga nilalaman ng file bilang isang string.
Maaari din tayong gumawa ng bagong direktoryo gamit ang function na fs::create_dir() at pagpasa ng path sa target na direktoryo bilang parameter.
Sa wakas, maaari nating alisin ang isang partikular na file gamit ang function na fs::remove_file() at ipasa ang target na file bilang parameter.
TANDAAN: Ang mga ibinigay na halimbawa ay ilang pangunahing halimbawa kung paano isagawa ang mga operasyon ng filesystem sa Linux gamit ang std::fs module. Nagbibigay ang Rust ng komprehensibong koleksyon ng mga pamamaraan at function na ipinapakita dito. Sumangguni sa dokumentasyon para matuto pa.
Pamamahala ng Proseso Gamit ang OS Module
Bilang maaari mong hulaan, ang OS module ay nagbibigay ng mga submodules at mga tampok upang gumana sa mga proseso sa system.
Kunin ang sumusunod na halimbawang code:
gumamit ng std::process:: { utos, labasan } ;fn kamay ( ) {
// patakbuhin ang ls utos
hayaan output = Utos::bago ( 'ls' )
.arg ( '-ang' )
.output ( )
.asahan ( 'Nabigong isagawa ang utos' ) ;
kung output.status.success ( ) {
hayaan stdout = String::from_utf8_lossy ( at output.stdout ) ;
println ! ( 'Output ng command: \n {}' , stdout ) ;
} iba pa {
hayaan stderr = String::from_utf8_lossy ( at output.stderr ) ;
eprintln ! ( 'Nabigo ang utos: \n {}' , stderr ) ;
labasan ( 1 ) ;
}
}
Sa ibinigay na halimbawa, magsisimula kami sa pamamagitan ng pag-import ng mga kinakailangang module. Sa kasong ito, kailangan namin ang 'command' at 'exit' na pamamaraan mula sa std::process submodule.
Pagkatapos ay ginagamit namin ang Command::new() function upang patakbuhin ang command na 'ls' at ipasa ang mga argumento sa command.
Kung matagumpay, dapat ibalik ng command ang listahan ng direktoryo para sa kasalukuyang gumaganang direktoryo tulad ng sumusunod:
Konklusyon
Ginalugad namin kung paano gamitin ang iba't ibang mga function at pamamaraan na ibinibigay ng std::os module at mga submodules upang magsagawa ng maramihang mga operasyon sa Linux at Unix-like system. Tandaan na ang std::os module ay isang malawak na module na naglalaman ng mas malawak na koleksyon ng mga feature kaysa sa mga ipinapakita sa tutorial na ito.