Există mai multe modalități de a gestiona erorile în Rust, așa că asigurați-vă că luați în considerare toate opțiunile.

Erorile sunt inevitabile și pot apărea din diverse motive, de la introducerea nevalidă a utilizatorului la defecțiuni în rețea, defecțiuni hardware sau erori de programare. Gestionarea erorilor este procesul de detectare, raportare și recuperare din astfel de erori pentru a preveni blocarea programelor sau coruperea datelor.

Gestionarea eficientă a erorilor este critică în Rust. Vă permite să creați aplicații robuste și fiabile, care pot face față erorilor și defecțiunilor neașteptate. Mecanismele Rust de gestionare a erorilor vă permit să dezvoltați programe rezistente, sigure, care sunt mai ușor de întreținut.

Tipurile de erori în Rust

Rust are un sistem de tip bogat pe care îl puteți folosi trata erorile cu pricepere, după tipurile lor. Beneficiile sistemului bogat de tip de eroare de la Rust față de abordările tradiționale de gestionare a erorilor nu pot fi subestimate. Sistemul de tip de eroare oferă

instagram viewer
siguranța de tip îmbunătățită, composabilitate, expresivitate și depanare.

Iată o listă de tipuri de erori comune în Rust:

  • The std:: io:: Eroare tipul reprezintă erori I/O, cum ar fi fișierul negăsit, permisiunea refuzată sau sfârșitul fișierului atins.
  • The std:: num:: ParseIntError tipul reprezintă erori care apar operațiuni de parsare șir la întreg.
  • The std:: opțiune:: NoneError tipul reprezintă erori de la despachetarea Opțiunilor goale.
  • The std:: rezultat:: Rezultat tipul este un tip de rezultat generic pe care îl puteți utiliza pentru a reprezenta orice eroare.

Fiecare tip de eroare are propriul său set de metode și trăsături pentru a-l gestiona în moduri specifice.

Iată un exemplu de gestionare a erorilor în Rust pentru o operație de citire a fișierelor:

utilizare std:: fs:: Fișier;
utilizare std:: io:: Citiți;
fnread_file(cale: &str) -> Rezultat<Şir, std:: io:: Eroare> {
lăsamut fișier = Fișier:: deschis (cale)?;
lăsamut continut = Şir::nou();
 file.read_to_string(&mut continut)?;
Bine(conținut)
}

The read_file funcția citește conținutul fișierului în calea specificată și îl returnează ca șir. Se întoarce a std:: io:: Eroare dacă operația de deschidere sau citire a fișierului eșuează. The ? operatorul propagă eroarea și returnează eroarea ca a Rezultat.

Mecanisme de tratare a erorilor în rugină

O caracteristică cheie care contribuie la siguranța Rust este mecanismele sale de tratare a erorilor. Există patru mecanisme principale de tratare a erorilor în Rust: Rezultat Tastați Opțiune Tastați panică! macro, iar Eroare trăsătură.

Tipurile Rezultat și Opțiune permit gestionarea structurată a erorilor. Puteți folosi panica! macro pentru a gestiona erorile irecuperabile. Trăsătura de eroare vă permite să definiți tipuri de erori personalizate și gestionarea personalizată a erorilor.

Tipul de rezultat

The Rezultat type este un tip încorporat care reprezintă rezultatul unei operații care poate eșua. Are două variante: cel Bine variantă, care reprezintă succesul și conține o valoare, și Err, care reprezintă eșecul și conține o valoare de eroare.

Iată cum puteți utiliza tipul de rezultat pentru a deschide un fișier și a citi conținutul acestuia:

utilizare std:: fs:: Fișier;
utilizare std:: io:: preludiu::*;
fnread_file(file_path: &str) -> Rezultat<Şir, std:: io:: Eroare> {
lăsamut fișier = Fișier:: deschis (file_path)?;
lăsamut continut = Şir::nou();
 file.read_to_string(&mut continut)?;
Bine(conținut)
}


fnprincipal() {
lăsa rezultat = read_file(„fișier.txt”);
Meci rezultat {
Bine(cuprins) => println!("{}", conținut),
Err(e) => println!(„Eroare: {}”, e),
 }
}

The read_file funcția preia calea fișierului și returnează a Rezultat eroare. Dacă operația de citire sau deschidere a fișierului eșuează, funcția returnează fișierul Err valoare. În caz contrar, funcția returnează Bine valoare. În principal funcția, cea Meci declarația se ocupă de Rezultat valoare și tipărește rezultatul în funcție de situația operației cu fișierul.

Tipul de opțiune

The Opțiune tipul este un tip încorporat care reprezintă prezența sau absența unei valori. The Opțiune tipul are două variante. niste reprezintă o valoare, și Nici unul reprezintă absenţa unei valori.

Iată cum puteți utiliza Opțiune tastați pentru a prelua primul element al unui vector.

fnobține_primul_elementClonează>(vec: Vec) -> Opțiune {
dacă vec.is_empty() {
Nici unul
 } altfel {
niste(vec.first().unwrap().clone())
 }
}
fnprincipal() {
lăsa vec = vec![1, 2, 3];
lăsa rezultat = obține_primul_element (vec);
Meci rezultat {
niste(element) => println!("{}", element),
Nici unul => println!(„Vectorul este gol”.),
 }
}

The obține_primul_element funcția returnează an Opțiune tip. Dacă vectorul este gol, funcția revine Nici unul; altfel, funcția revine niste conţinând primul element al vectorului. În principal funcția, cea Meci declarația se ocupă de Opțiune valoare. Dacă Opțiune evaluează să niste, funcția imprimă primul element. În caz contrar, funcția afișează un mesaj care indică faptul că vectorul este gol.

Panica! Macro

The panică! macro oferă funcționalitate pentru gestionarea erorilor irecuperabile în Rust. La apelarea panică! macro, imprimă un mesaj de eroare și închide programul.

Iată un exemplu de utilizare a panicii! macro pentru a indica faptul că o funcție are argumente nevalide.

fndivide(dividend: f64, divizor: f64) -> f64 {
dacă divizor == 0.0 {
panică!(„Divizorul nu poate fi zero”.);
 }
 dividend / divizor
}
fnprincipal() {
lăsa rezultat = divide(4.0, 0.0);
println!("{}", rezultat);
}

The divide funcția verifică dacă divizorul este zero; dacă divizorul este zero, funcția numește panică! macro cu un mesaj de eroare; în caz contrar, funcția calculează și returnează rezultatul

The principal funcția apelează funcția divide cu argumente nevalide pentru a declanșa panică! macro.

Iată mesajul de eroare:

Trăsătura de eroare

The Eroare trăsătura este o trăsătură încorporată care definește comportamentul tipurilor de erori. The Eroare trăsătura oferă funcționalitate pentru definirea tipurilor de erori personalizate și gestionarea personalizată a erorilor.

Iată un exemplu de definire a unui tip de eroare personalizat care reprezintă o eroare de fișier negăsit.

utilizare std:: eroare:: Eroare;
utilizare std:: fmt;
utilizare std:: io:: Citiți;
#[derivare (Depanare)]
structFișierul nu a fost găsit(Şir);


impl fmt:: Afișare pentru Fișierul nu a fost găsit {
fnfmt(&de sine, f: &mut fmt:: Formatator) -> fmt::Rezultat {
scrie!(f, "Fișierul nu a fost găsit: {}", de sine.0)
 }
}


impl Eroare pentru Fișierul nu a fost găsit {}


fnread_file(file_path: &str) -> Rezultat<Şir, Cutie<din Eroare>> {
lăsamut fișier = std:: fs:: Fișier:: deschis (file_path).map_err(|e| FileNotFound(format!("{}", e)))?;
lăsamut continut = Şir::nou();
 file.read_to_string(&mut continut)?;
Bine(conținut)
}


fnprincipal() {
lăsa rezultat = read_file(„fișier.txt”);
Meci rezultat {
Bine(cuprins) => println!("{}", conținut),
Err(e) => println!(„Eroare: {}”, e),
 }
}

Tipul de eroare personalizat este Fișierul nu a fost găsit struct. Tipul conține o cale de fișier și Fișierul nu a fost găsit tip implementează Afişa caracteristică pentru a returna mesaje de eroare ușor de utilizat și Eroare trăsătură pentru a indica faptul că acesta este un tip de eroare.

În read_file funcția, cea Fișierul nu a fost găsit tipul de eroare reprezintă o eroare de fișier negăsit, iar fișierul map_err metoda convertește eroarea std:: io:: într-o eroare FileNotFound. In cele din urma, cutia type permite funcției să returneze orice tip care implementează trăsătura Error.

The principal funcția apelează read_file funcția cu calea fișierului și, dacă găsește fișierul, imprimă conținutul acestuia pe consolă. În caz contrar, imprimă mesajul de eroare.

Iată rezultatul pentru un fișier care nu există:

Vă puteți baza pe modelul de proprietate al Rust pentru siguranța programului

Împreună cu mecanismul magnific de gestionare a erorilor de la Rust, Rust utilizează, de asemenea, un model de proprietate care vă ajută să vă asigurați că programele dumneavoastră sunt sigure pentru memorie.

Rust asigură regulile de proprietate cu un verificator de împrumut în timpul compilării înainte ca programul să ruleze.