Rust std::os modulis nodrošina operētājsistēmas funkcionalitātes abstrakciju. Tas ļauj mums mijiedarboties ar pamatā esošo operētājsistēmu, lai strādātu ar vides mainīgajiem, failu sistēmas operācijām, procesu pārvaldību un daudz ko citu.
Šajā piemērā mēs apskatīsim dažas pamata darbības, kuras varat veikt operētājsistēmā Unix, izmantojot Rust std::os moduli.
Ir labi atcerēties, ka šis ir plašs modulis un tajā ir daudz veidu un funkciju dažādām ar Unix saistītām operācijām. Tāpēc, lūdzu, apskatiet dokumentāciju, lai sniegtu atsauci par attiecīgajiem procesiem.
Rust OS operētājsistēmā Linux
Operētājsistēmā Linux mēs varam piekļūt Unix specifiskajām funkcijām un veidiem, ko nodrošina std::os::unix modulis, kas ir Rust moduļa std::os apakšmodulis.
Šis modulis ir daļa no Rust standarta bibliotēkas, un tāpēc nav nepieciešams instalēt ārēju kasti vai atkarības.
Apskatīsim dažas pamata API un darbības, kuras mēs varam veikt Linux sistēmā no šī moduļa.
Piekļuve vides mainīgajiem
Mēs varam piekļūt vides mainīgajiem, izmantojot std::env moduli. Piemēram, std::env::var(“PATH”) izgūst PATH vides mainīgā vērtību.
Apsveriet šādu programmas piemēru:
izmantot std::env;izmantot std::ffi::OsString;
fn roka ( ) {
// Piekļūstiet konkrētam vides mainīgajam
ja ļaut Labi ( vērtību ) = env::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , vērtība ) ;
}
// Atkārtojiet visus vides mainīgos
priekš ( atslēga, vērtība ) iekšā env::wars_us ( ) {
ļaut key_string = key.to_string_lossy ( ) ;
ļaut value_string = value.to_string_lossy ( ) ;
println ! ( '{}:{}' , atslēgas_virkne, vērtību_virkne ) ;
}
// Piekļūstiet konkrētam vides mainīgajam kā an ` OsString `
ja ļaut Dažas ( vērtību ) = env::var_us ( 'HOSTTYPE' ) {
// Konvertēt ` OsString ` uz a ` Stīga ` ja nepieciešams
ja ļaut Dažas ( value_str ) = value.to_str ( ) {
println ! ( 'HOSTTYPE={}' , value_str ) ;
}
}
}
Dotajā piemērā mēs sākam ar nepieciešamo moduļu importēšanu. Šajā gadījumā mūs interesē std::env un std::ff::OsString.
Lai piekļūtu konkrētam vides mainīgajam, mēs varam izmantot funkciju env::var un nodot tās vērtības nosaukumu, kuru vēlamies ienest. Šajā gadījumā mēs iegūstam mainīgā WAYLAND_DISPLAY vērtību.
Funkcija atgriež mainīgā vērtību kā rezultāta tipu.
Mēs varam arī atkārtot visus vides mainīgos, izmantojot funkciju env::vars_os. Tas atgriež iteratoru ar vides mainīgo atslēgu-vērtību pāriem. Ir vērts atzīmēt, ka vērtības tiek atgrieztas kā OsString tips. Pēc tam mēs varam pārvērst tos virkņu vērtībās, izmantojot funkciju to_string_lossy.
Mēs varam arī piekļūt konkrētiem vides mainīgajiem, izmantojot funkciju env::var_os. Tam vajadzētu atgriezt tipu
Rezultātā iegūtais rezultāts ir šāds:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
FS operācijas, izmantojot OS moduli
Kā jūs varat uzminēt, OS modulis nodrošina dažādas funkcijas un metodes, lai veiktu ar failu sistēmu saistītās darbības.
Paņemiet šo programmu, kas parāda dažādas darbības, kuras mēs varam veikt, izmantojot std::os moduli operētājsistēmā Linux:
izmantot std::fs;fn roka ( ) {
// Izlasi a failu
ja ļaut Labi ( saturu ) = fs::lasīt_virknei ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , saturs ) ;
}
// Izveidojiet jaunu direktoriju
ja ļaut Err ( kļūda ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Neizdevās izveidot direktoriju: {}' , kļūda ) ;
}
// Noņemt a failu
ja ļaut Err ( kļūda ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Neizdevās noņemt failu: {}' , kļūda ) ;
}
}
Dotajā piemērā mēs demonstrējam, kā mēs varam nolasīt faila saturu, izmantojot fs::read_to_string() metodi. Metode izmanto ceļu uz mērķa failu un atgriež faila saturu kā virkni.
Mēs varam arī izveidot jaunu direktoriju, izmantojot funkciju fs::create_dir() un kā parametru nododot ceļu uz mērķa direktoriju.
Visbeidzot, mēs varam noņemt konkrētu failu, izmantojot funkciju fs::remove_file() un nodot mērķa failu kā parametru.
PIEZĪME: Sniegtie piemēri ir daži pamata piemēri, kā veikt failu sistēmas darbības operētājsistēmā Linux, izmantojot moduli std::fs. Rust nodrošina visaptverošu metožu un funkciju kolekciju, kas ir parādītas šeit. Lai uzzinātu vairāk, skatiet dokumentāciju.
Procesu pārvaldība, izmantojot OS moduli
Kā jau nojaušat, OS modulis nodrošina apakšmoduļus un līdzekļus darbam ar sistēmas procesiem.
Izmantojiet šādu koda piemēru:
izmantot std::process:: { komanda, Izeja } ;fn roka ( ) {
// palaist ls komandu
ļaut izvade = Command::new ( 'ls' )
.arg ( '-the' )
.izeja ( )
.gaidīt ( 'Neizdevās izpildīt komandu' ) ;
ja izvade.statuss.veiksme ( ) {
ļaut stdout = String::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'Komandu izvade: \n {}' , stdout ) ;
} cits {
ļaut stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'Komanda neizdevās: \n {}' , stderr ) ;
Izeja ( 1 ) ;
}
}
Dotajā piemērā mēs sākam ar nepieciešamo moduļu importēšanu. Šajā gadījumā mums ir nepieciešamas “komandu” un “izejas” metodes no std::process apakšmoduļa.
Pēc tam mēs izmantojam funkciju Command::new(), lai palaistu komandu “ls” un nodotu komandai argumentus.
Ja tā ir veiksmīga, komandai jāatgriež pašreizējā darba direktorija direktoriju saraksts šādi:
Secinājums
Mēs izpētījām, kā izmantot dažādas funkcijas un metodes, ko nodrošina std::os modulis un apakšmoduļi, lai veiktu vairākas darbības Linux un Unix līdzīgās sistēmās. Atcerieties, ka std::os modulis ir plašs modulis, kas satur plašāku funkciju kolekciju nekā šajā apmācībā parādītās.