În Rust, modulul std::os oferă o abstractizare asupra funcționalității sistemului de operare. Ne permite să interacționăm cu sistemul de operare de bază pentru a lucra cu variabilele de mediu, operațiunile sistemului de fișiere, managementul proceselor și multe altele.
În acest exemplu, vom acoperi câteva operațiuni fundamentale pe care le puteți efectua pe Unix folosind modulul Rust std::os.
Este bine de reținut că acesta este un modul extins și conține multe tipuri și funcții pentru diferite operațiuni legate de Unix. Prin urmare, vă rugăm să luați în considerare documentația pentru referință privind procesele corespunzătoare.
Rust OS în Linux
În Linux, putem accesa funcțiile și tipurile specifice Unix care sunt furnizate de modulul std::os::unix, un submodul al modulului std::os din Rust.
Acest modul face parte din biblioteca standard Rust și, prin urmare, nu necesită să instalați nicio cudă externă sau dependențe.
Să acoperim câteva API și operațiuni de bază pe care le putem efectua pe un sistem Linux din acest modul.
Accesarea variabilelor de mediu
Putem accesa variabilele de mediu folosind modulul std::env. De exemplu, std::env::var(„PATH”) preia valoarea variabilei de mediu PATH.
Luați în considerare următorul exemplu de program:
utilizați std::env;utilizați std::ffi::OsString;
fn mână ( ) {
// Accesați o anumită variabilă de mediu
dacă lăsa Bine ( valoare ) = env::var ( „WAYLAND_DISPLAY” ) {
println ! ( „WAYLAND_DISPLAY={}” , valoare ) ;
}
// Iterați peste toate variabilele de mediu
pentru ( valoare cheie ) în env::wars_us ( ) {
lăsa key_string = key.to_string_losssy ( ) ;
lăsa value_string = value.to_string_losssy ( ) ;
println ! ( „{}:{}” , șir_cheie, șir_valoare ) ;
}
// Accesați o anumită variabilă de mediu la fel de un ` OsString `
dacă lăsa niste ( valoare ) = env::var_us ( „HOSTTYPE” ) {
// Convertit ` OsString ` la a ` Şir ` dacă Necesar
dacă lăsa niste ( value_str ) = valoare.la_str ( ) {
println ! ( „HOSTTYPE={}” , value_str ) ;
}
}
}
În exemplul dat, începem prin a importa modulele necesare. În acest caz, ne interesează std::env și std::ff::OsString.
Pentru a accesa o anumită variabilă de mediu, putem folosi funcția env::var și transmitem numele valorii pe care dorim să o obținem. În acest caz, obținem valoarea variabilei WAYLAND_DISPLAY.
Funcția returnează valoarea variabilei ca tip de rezultat.
De asemenea, putem itera peste toate variabilele de mediu folosind funcția env::vars_os. Aceasta returnează un iterator cu perechile cheie-valoare ale variabilelor de mediu. Este bine de remarcat că valorile sunt returnate ca tip OsString. Apoi le putem converti în valori de șir folosind funcția to_string_lossy.
De asemenea, putem accesa variabilele de mediu specifice folosind funcția env::var_os. Aceasta ar trebui să returneze un tip
Rezultatul rezultat este după cum urmează:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
Operații FS folosind modulul OS
După cum puteți ghici, modulul OS oferă diverse funcții și metode pentru a efectua operațiunile legate de sistemul de fișiere.
Luați următorul program care demonstrează diferitele operațiuni pe care le putem efectua folosind modulul std::os în Linux:
utilizați std::fs;fn mână ( ) {
// Citeste o fişier
dacă lăsa Bine ( continuturi ) = fs::read_to_string ( „/home/debian/.bashrc” ) {
println ! ( „bashrc: {}” , cuprins ) ;
}
// Creați un director nou
dacă lăsa Err ( a greșit ) = fs::create_dir ( „/home/debian/new_dir” ) {
eprintln ! ( „Nu s-a putut crea directorul: {}” , greșeală ) ;
}
// Eliminați a fişier
dacă lăsa Err ( a greșit ) = fs::remove_file ( „/home/debian/remove_me.txt” ) {
eprintln ! ( „Eșuare la eliminarea fișierului: {}” , greșeală ) ;
}
}
În exemplul dat, demonstrăm cum putem citi conținutul unui fișier folosind metoda fs::read_to_string(). Metoda ia calea către fișierul țintă și returnează conținutul fișierului ca șir.
De asemenea, putem crea un nou director folosind funcția fs::create_dir() și trecând calea către directorul țintă ca parametru.
În cele din urmă, putem elimina un anumit fișier utilizând funcția fs::remove_file() și transmitem fișierul țintă ca parametru.
NOTĂ: Exemplele oferite sunt câteva exemple de bază despre cum să efectuați operațiunile sistemului de fișiere pe Linux folosind modulul std::fs. Rust oferă o colecție cuprinzătoare de metode și funcții care sunt demonstrate aici. Consultați documentația pentru a afla mai multe.
Managementul proceselor folosind modulul OS
După cum puteți ghici, modulul OS oferă submodule și caracteristici pentru a lucra cu procesele din sistem.
Luați următorul exemplu de cod:
utilizați std::process:: { Comanda, Ieșire } ;fn mână ( ) {
// rulează ls comanda
lăsa output = Command::new ( 'ls' )
.arg ( '-cel' )
.ieșire ( )
.aştepta ( „Eșec la executarea comenzii” ) ;
dacă ieșire.stare.succes ( ) {
lăsa stdout = String::from_utf8_lossy ( & ieșire.stdout ) ;
println ! ( „Ieșire comandă: \n {}' , stdout ) ;
} altfel {
lăsa stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( „Comanda a eșuat: \n {}' , stderr ) ;
Ieșire ( 1 ) ;
}
}
În exemplul dat, începem prin a importa modulele necesare. În acest caz, avem nevoie de metodele „comandă” și „ieșire” din submodulul std::process.
Apoi folosim funcția Command::new() pentru a rula comanda „ls” și a transmite argumentele comenzii.
Dacă are succes, comanda ar trebui să returneze lista de director pentru directorul de lucru curent, după cum urmează:
Concluzie
Am explorat cum să folosim diferitele funcții și metode care sunt furnizate de modulul și submodulele std::os pentru a efectua operații multiple în sistemele Linux și Unix. Rețineți că modulul std::os este un modul extins care conține o colecție mai largă de caracteristici decât cele care sunt demonstrate în acest tutorial.