Ir vairāk nekā viens veids, kā apstrādāt Rust kļūdas, tāpēc noteikti apsveriet visas iespējas.

Kļūdas ir neizbēgamas un var rasties dažādu iemeslu dēļ, sākot no nederīgas lietotāja ievades līdz tīkla kļūmēm, aparatūras darbības traucējumiem vai programmēšanas kļūdām. Kļūdu apstrāde ir šādu kļūdu noteikšanas, ziņošanas un atkopšanas process, lai novērstu programmu avārijas vai datu bojājumus.

Rust ir ļoti svarīga efektīva kļūdu apstrāde. Tas ļauj jums izveidot spēcīgas, uzticamas lietojumprogrammas, kas var tikt galā ar negaidītām kļūdām un kļūmēm. Rust kļūdu apstrādes mehānismi ļauj izstrādāt elastīgas, drošas programmas, kuras ir vieglāk uzturēt.

Rūsas kļūdu veidi

Rust ir bagāta tipa sistēma, kuru varat izmantot prasmīgi rīkoties ar kļūdām, atbilstoši to veidiem. Rust bagātīgās kļūdu tipa sistēmas priekšrocības salīdzinājumā ar tradicionālajām kļūdu apstrādes metodēm nevar novērtēt par zemu. Kļūdu veidu sistēma nodrošina uzlabota tipa drošība, komponējamība, izteiksmīgums un atkļūdojamība.

instagram viewer

Šeit ir Rust izplatītāko kļūdu veidu saraksts:

  • The std:: io:: Kļūda tips apzīmē I/O kļūdas, piemēram, fails nav atrasts, atļauja liegta vai ir sasniegtas faila beigas.
  • The std:: num:: ParseIntError tips apzīmē kļūdas, kas rodas virknes līdz veselam skaitļam parsēšanas operācijām.
  • The std:: opcija:: NoneError tips apzīmē kļūdas, kas radušās, attinot tukšas opcijas.
  • The std:: rezultāts:: Rezultāts tips ir vispārīgs rezultāta veids, ko varat izmantot, lai attēlotu jebkuru kļūdu.

Katram kļūdas veidam ir savs metožu un iezīmju kopums, lai to apstrādātu noteiktos veidos.

Šeit ir piemērs kļūdu apstrādei Rust faila lasīšanas operācijā:

izmantot std:: fs:: Fails;
izmantot std:: io:: Lasīt;
fnlasīt_failu(ceļš: &str) -> Rezultāts<Stīga, std:: io:: Kļūda> {
ļautmut file = Fails:: atvērt (ceļš)?;
ļautmut saturs = Stīga::jauns();
 file.read_to_string(&mut saturs)?;
Labi(saturs)
}

The lasīt_failu funkcija nolasa faila saturu norādītajā ceļā un atgriež to kā virkni. Tas atgriež a std:: io:: Kļūda ja faila atvēršanas vai lasīšanas darbība neizdodas. The ? operators izplata kļūdu un atgriež kļūdu kā a Rezultāts.

Kļūdu apstrādes mehānismi rūsā

Viena no galvenajām īpašībām, kas veicina Rust drošību, ir tā kļūdu apstrādes mehānismi. Rust ir četri galvenie kļūdu apstrādes mehānismi: Rezultāts tips, Opcija tips, panika! makro un Kļūda īpašība.

Veidi Rezultāts un opcija nodrošina strukturētu kļūdu apstrādi. Jūs varat izmantot paniku! makro, lai apstrādātu neatkopjamas kļūdas. Kļūdu iezīme ļauj definēt pielāgotus kļūdu veidus un pielāgotu kļūdu apstrādi.

Rezultāta veids

The Rezultāts tips ir iebūvēts tips, kas atspoguļo tādas darbības rezultātu, kas var neizdoties. Tam ir divi varianti: Labi variants, kas apzīmē panākumus un satur vērtību, un Err, kas apzīmē kļūmi un satur kļūdas vērtību.

Lūk, kā varat izmantot rezultātu veidu, lai atvērtu failu un lasītu tā saturu.

izmantot std:: fs:: Fails;
izmantot std:: io:: prelūdija::*;
fnlasīt_failu(faila_ceļš: &str) -> Rezultāts<Stīga, std:: io:: Kļūda> {
ļautmut file = Fails:: atvērt (faila_ceļš)?;
ļautmut saturs = Stīga::jauns();
 file.read_to_string(&mut saturs)?;
Labi(saturs)
}


fngalvenais() {
ļaut rezultāts = read_file("fails.txt");
atbilst rezultāts {
Labi(saturs) => println!("{}", saturs),
Err(e) => println!("Kļūda: {}", e),
 }
}

The lasīt_failu funkcija aizņem faila ceļu un atgriež a Rezultāts kļūda. Ja faila lasīšanas vai atvēršanas darbība neizdodas, funkcija atgriež Err vērtību. Pretējā gadījumā funkcija atgriež Labi vērtību. Iekš galvenais funkcija, atbilst paziņojums apstrādā Rezultāts vērtību un izdrukā rezultātu atkarībā no faila darbības situācijas.

Opcijas veids

The Opcija tips ir iebūvēts tips, kas atspoguļo vērtības esamību vai neesamību. The Opcija tipam ir divi varianti. Dažas apzīmē vērtību un Nav apzīmē vērtības neesamību.

Lūk, kā varat izmantot Opcija ierakstiet, lai izgūtu vektora pirmo elementu.

fnget_first_elementKlonēt> (vec: Vec) -> Opcija {
ja vec.is_empty() {
Nav
 } cits {
Dažas(vec.first().unwrap().clone())
 }
}
fngalvenais() {
ļaut vec = vec![1, 2, 3];
ļaut rezultāts = get_first_element (vec);
atbilst rezultāts {
Dažas(elements) => println!("{}", elements),
Nav => println!("Vektors ir tukšs."),
 }
}

The get_first_element funkcija atgriež an Opcija veids. Ja vektors ir tukšs, funkcija atgriežas Nav; pretējā gadījumā funkcija atgriežas Dažas kas satur vektora pirmo elementu. Iekš galvenais funkcija, atbilst paziņojums apstrādā Opcija vērtību. Ja Opcija novērtē uz Dažas, funkcija izdrukā pirmo elementu. Pretējā gadījumā funkcija izdrukā ziņojumu, kas norāda, ka vektors ir tukšs.

Panika! Makro

The panika! makro nodrošina funkcionalitāti, lai apstrādātu neatgriezeniskas kļūdas programmā Rust. Zvanot uz panika! makro, tas izdrukā kļūdas ziņojumu un pārtrauc programmas darbību.

Lūk, piemērs panikas izmantošanai! makro, lai norādītu, ka funkcijai ir nederīgi argumenti.

fnsadalīt(dalāmais: f64, dalītājs: f64) -> f64 {
ja dalītājs == 0.0 {
panika!("Dalītājs nevar būt nulle.");
 }
 dividende / dalītājs
}
fngalvenais() {
ļaut rezultāts = dalīšana (4.0, 0.0);
println!("{}", rezultāts);
}

The sadalīt funkcija pārbauda, ​​vai dalītājs ir nulle; ja dalītājs ir nulle, funkcija izsauc panika! makro ar kļūdas ziņojumu; pretējā gadījumā funkcija aprēķina un atgriež rezultātu

The galvenais funkcija izsauc dalīšanas funkciju ar nederīgiem argumentiem, lai aktivizētu panika! makro.

Šeit ir kļūdas ziņojums:

Kļūdas iezīme

The Kļūda īpašība ir iebūvēta iezīme, kas nosaka kļūdu veidu uzvedību. The Kļūda īpašība nodrošina funkcionalitāti pielāgotu kļūdu veidu definēšanai un pielāgotu kļūdu apstrādei.

Tālāk ir sniegts piemērs pielāgota kļūdas veida definēšanai, kas apzīmē kļūdu, kas nav atrasta failā.

izmantot std:: error:: Error;
izmantot std:: fmt;
izmantot std:: io:: Lasīt;
#[atvasināt (atkļūdot)]
struktūraFails nav atrasts(Stīga);


impl fmt:: Displejs priekš Fails nav atrasts {
fnfmt(&sevi, f: &mut fmt:: Formatētājs) -> fmt::Rezultāts {
raksti!(f, "Fails nav atrasts: {}", sevi.0)
 }
}


impl Kļūda priekš Fails nav atrasts {}


fnlasīt_failu(faila_ceļš: &str) -> Rezultāts<Stīga, Kaste<dyn Kļūda>> {
ļautmut fails = std:: fs:: Fails:: atvērts (faila_ceļš).map_err(|e| FileNotFound(formātā!("{}", e)))?;
ļautmut saturs = Stīga::jauns();
 file.read_to_string(&mut saturs)?;
Labi(saturs)
}


fngalvenais() {
ļaut rezultāts = read_file("fails.txt");
atbilst rezultāts {
Labi(saturs) => println!("{}", saturs),
Err(e) => println!("Kļūda: {}", e),
 }
}

Pielāgotais kļūdas veids ir Fails nav atrasts struktūra. Veidā ir faila ceļš un Fails nav atrasts tips īsteno Displejs iezīme atgriezt lietotājam draudzīgus kļūdu ziņojumus un Kļūda īpašība, kas norāda, ka tas ir kļūdas veids.

Iekš lasīt_failu funkcija, Fails nav atrasts kļūdas veids apzīmē kļūdu fails nav atrasts, un map_err metode pārvērš std:: io:: kļūdu par FileNotFound kļūdu. Visbeidzot, kaste tips ļauj funkcijai atgriezt jebkuru tipu, kas ievieš kļūdu iezīmi.

The galvenais funkcija izsauc lasīt_failu funkcija ar faila ceļu un, ja tā atrod failu, izdrukā tā saturu konsolē. Pretējā gadījumā tas izdrukā kļūdas ziņojumu.

Tālāk ir norādīts neesoša faila rezultāts:

Varat izmantot Rust īpašumtiesību modeli programmas drošībai

Kopā ar Rust lielisko kļūdu apstrādes mehānismu Rust izmanto arī īpašumtiesību modeli, kas palīdz nodrošināt, ka jūsu programmas ir drošas atmiņā.

Rust nodrošina īpašumtiesību noteikumus, izmantojot aizņemšanās pārbaudītāju kompilēšanas laikā, pirms jūsu programma darbojas.