Rusti vigade käsitlemiseks on rohkem kui üks viis, seega kaaluge kindlasti kõiki võimalusi.

Vead on vältimatud ja võivad ilmneda erinevatel põhjustel, alates vigasest kasutaja sisendist kuni võrgutõrgete, riistvara tõrgete või programmeerimisvigadeni. Vigade käsitlemine on selliste vigade tuvastamise, nendest teatamise ja nendest taastamise protsess, et vältida programmi kokkujooksmisi või andmete rikkumist.

Tõhus vigade käsitlemine on Rustis kriitilise tähtsusega. See võimaldab teil luua tugevaid ja usaldusväärseid rakendusi, mis saavad hakkama ootamatute vigade ja tõrgetega. Rooste veatöötlusmehhanismid võimaldavad teil arendada vastupidavaid ja turvalisi programme, mida on lihtsam hooldada.

Rooste vigade tüübid

Rustil on rikkaliku tüüpi süsteem, mida saate kasutada vigadega oskuslikult hakkama saada, vastavalt nende tüüpidele. Rusti rikkaliku veatüüpi süsteemi eeliseid võrreldes traditsiooniliste veakäsitlemismeetoditega ei saa alahinnata. Veatüübi süsteem pakub täiustatud tüüpi ohutus, komponeeritavus, väljendusrikkus ja silutavus.

instagram viewer

Siin on Rusti levinumate veatüüpide loend:

  • The std:: io:: Viga tüüp tähistab sisend-/väljundvigu, nagu faili ei leitud, luba on keelatud või faili lõppu on jõutud.
  • The std:: num:: ParseIntError tüüp tähistab tõrkeid, mis ilmnevad stringist täisarvude parsimise operatsioonides.
  • The std:: valik:: NoneError tüüp tähistab tühjade valikute lahtipakkimisel tekkinud vigu.
  • The std:: tulemus:: Tulemus tüüp on üldine tulemuse tüüp, mida saate kasutada mis tahes vea esitamiseks.

Igal veatüübil on oma meetodid ja tunnused selle konkreetsel viisil käsitlemiseks.

Siin on näide veakäsitlusest Rustis faili lugemise toimingu jaoks:

kasutada std:: fs:: Fail;
kasutada std:: io:: Loe;
fnloe_fail(tee: &str) -> Tulemus<String, std:: io:: Viga> {
lasemut file = Fail:: avatud (tee)?;
lasemut sisu = String::uus();
 file.read_to_string(&mut sisu)?;
Okei(sisu)
}

The loe_fail funktsioon loeb määratud teel oleva faili sisu ja tagastab selle stringina. See tagastab a std:: io:: Viga kui faili avamise või lugemise toiming ebaõnnestub. The ? operaator levitab vea ja tagastab vea kui a Tulemus.

Rooste tõrketöötlusmehhanismid

Üks põhifunktsioon, mis aitab kaasa Rusti ohutusele, on selle veakäsitlusmehhanismid. Rustis on neli peamist vigade käsitlemise mehhanismi: Tulemus tüüp, Võimalus tüüp, paanika! makro ja Viga omadus.

Tüübid Tulemus ja Suvand võimaldavad struktureeritud vigade käsitlemist. Võite paanikat kasutada! makro parandamatute vigade käsitlemiseks. Funktsioon Error võimaldab teil määrata kohandatud veatüübid ja kohandatud veakäsitluse.

Tulemuse tüüp

The Tulemus tüüp on sisseehitatud tüüp, mis esindab toimingu tulemust, mis võib ebaõnnestuda. Sellel on kaks varianti: Okei variant, mis tähistab edu ja sisaldab väärtust, ja Err, mis tähistab ebaõnnestumist ja sisaldab vea väärtust.

Siit saate teada, kuidas saate faili avamiseks ja selle sisu lugemiseks kasutada tüüpi Tulemust.

kasutada std:: fs:: Fail;
kasutada std:: io:: prelüüd::*;
fnloe_fail(faili teekond: &str) -> Tulemus<String, std:: io:: Viga> {
lasemut file = Fail:: avatud (faili_tee)?;
lasemut sisu = String::uus();
 file.read_to_string(&mut sisu)?;
Okei(sisu)
}


fnpeamine() {
lase tulemus = read_file("fail.txt");
vaste tulemus {
Okei(sisu) => println!("{}", sisu),
Err(e) => println!("Viga: {}", e),
 }
}

The loe_fail funktsioon võtab failitee sisse ja tagastab a Tulemus viga. Kui faili lugemise või avamise toiming ebaõnnestub, tagastab funktsioon Err väärtus. Vastasel juhul tagastab funktsioon Okei väärtus. Aastal peamine funktsioon, vaste avaldus käsitleb Tulemus väärtus ja prindib tulemuse sõltuvalt failitoimingu olukorrast.

Valiku tüüp

The Võimalus tüüp on sisseehitatud tüüp, mis tähistab väärtuse olemasolu või puudumist. The Võimalus tüübil on kaks varianti. Mõned esindab väärtust ja Mitte ühtegi tähistab väärtuse puudumist.

Siin on, kuidas saate kasutada Võimalus vektori esimese elemendi hankimiseks tippige.

fnhanki_esimene_elementKlooni> (vec: Vec) -> Võimalus {
kui vec.is_empty() {
Mitte ühtegi
 } muidu {
Mõned(vec.first().unwrap().clone())
 }
}
fnpeamine() {
lase vec = vec![1, 2, 3];
lase tulemus = hanki_esimene_element (vec);
vaste tulemus {
Mõned(element) => println!("{}", element),
Mitte ühtegi => println!("Vektor on tühi."),
 }
}

The hanki_esimene_element funktsioon tagastab an Võimalus tüüp. Kui vektor on tühi, naaseb funktsioon Mitte ühtegi; muul juhul tagastab funktsioon Mõned mis sisaldab vektori esimest elementi. Aastal peamine funktsioon, vaste avaldus käsitleb Võimalus väärtus. Kui Võimalus hindab kuni Mõned, prindib funktsioon esimese elemendi. Vastasel juhul prindib funktsioon teate, mis näitab, et vektor on tühi.

Paanika! Makro

The paanika! makro pakub funktsiooni Rusti taastamatute vigade käsitlemiseks. Helistades paanika! makro, prindib see veateate ja lõpetab programmi.

Siin on näide paanika kasutamisest! makro, mis näitab, et funktsioonil on kehtetud argumendid.

fnjagama(dividend: f64, jagaja: f64) -> f64 {
kui jagaja == 0.0 {
paanika!("Jagaja ei saa olla null.");
 }
 dividend / jagaja
}
fnpeamine() {
lase tulemus = jaga (4.0, 0.0);
println!("{}", tulemus);
}

The jagama funktsioon kontrollib, kas jagaja on null; kui jagaja on null, kutsub funktsioon välja paanika! makro veateatega; vastasel juhul funktsioon arvutab ja tagastab tulemuse

The peamine funktsioon kutsub välja jagamisfunktsiooni kehtetute argumentidega, et käivitada paanika! makro.

Siin on veateade:

Vea tunnus

The Viga tunnus on sisseehitatud tunnus, mis määrab veatüüpide käitumise. The Viga omadus pakub funktsioone kohandatud veatüüpide ja kohandatud veakäsitluse määratlemiseks.

Siin on näide kohandatud veatüübi määratlemisest, mis tähistab faili ei leitud viga.

kasutada std:: error:: Error;
kasutada std:: fmt;
kasutada std:: io:: Loe;
#[tuletada (silumine)]
struktuurFaili ei leitud(String);


impl fmt:: Ekraan jaoks Faili ei leitud {
fnfmt(&ise, f: &mut fmt:: vormindaja) -> fmt::Tulemus {
kirjuta!(f, "Faili ei leitud: {}", ise.0)
 }
}


impl Viga jaoks Faili ei leitud {}


fnloe_fail(faili teekond: &str) -> Tulemus<String, Kast<dyn Viga >> {
lasemut file = std:: fs:: Fail:: open (faili_tee).map_err(|e| FileNotFound(formaat!("{}", e)))?;
lasemut sisu = String::uus();
 file.read_to_string(&mut sisu)?;
Okei(sisu)
}


fnpeamine() {
lase tulemus = read_file("fail.txt");
vaste tulemus {
Okei(sisu) => println!("{}", sisu),
Err(e) => println!("Viga: {}", e),
 }
}

Kohandatud vea tüüp on Faili ei leitud struktuur. Tüüp sisaldab failiteed ja Faili ei leitud tüüp rakendab Ekraan omadus tagastada kasutajasõbralikke veateateid ja Viga tunnus, mis näitab, et see on veatüüp.

Aastal loe_fail funktsioon, Faili ei leitud vea tüüp tähistab faili ei leitud viga ja map_err meetod teisendab std:: io:: vea FileNotFoundi veaks. Lõpuks kast tüüp võimaldab funktsioonil tagastada mis tahes tüüpi, mis rakendab tunnust Error.

The peamine funktsioon kutsub esile loe_fail funktsioon faili teega ja kui see leiab faili, prindib selle sisu konsooli. Vastasel juhul prindib see veateate.

Siin on tulemus faili kohta, mida pole olemas:

Saate programmi ohutuse tagamiseks panustada Rusti omandimudelisse

Koos Rusti suurepärase veatöötlusmehhanismiga kasutab Rust ka omandimudelit, mis aitab tagada, et teie programmid on mälus ohutud.

Rust tagab omandireeglid laenukontrolliga kompileerimise ajal enne teie programmi käivitamist.