Rūdžių klaidų valdymas įvairiais būdais

Klaidos yra neišvengiamos ir gali atsirasti dėl įvairių priežasčių – nuo ​​neteisingos vartotojo įvesties iki tinklo gedimų, aparatinės įrangos gedimų ar programavimo klaidų. Klaidų tvarkymas – tai tokių klaidų aptikimo, ataskaitų teikimo ir atkūrimo procesas, siekiant išvengti programos strigčių ar duomenų sugadinimo.

Veiksmingas klaidų valdymas yra labai svarbus „Rust“. Tai leidžia kurti tvirtas, patikimas programas, kurios gali susidoroti su netikėtomis klaidomis ir gedimais. „Rust“ klaidų valdymo mechanizmai leidžia kurti atsparias, saugias programas, kurias lengviau prižiūrėti.

Rūdžių klaidų rūšys

Rust turi turtingo tipo sistemą, kurią galite naudoti meistriškai tvarkyti klaidas, pagal jų rūšis. Neįmanoma nuvertinti turtingos „Rust“ klaidų tipo sistemos pranašumų, palyginti su tradiciniais klaidų valdymo metodais. Klaidos tipo sistema numato patobulinta tipo sauga, komponuojamumas, išraiškingumas ir derinimas.

Štai dažniausių Rust klaidų tipų sąrašas:

• The std:: io:: Klaida tipas reiškia įvesties / išvesties klaidas, pvz., failas nerastas, leidimas uždraustas arba pasiektas failo pabaiga.
• The std:: num:: ParseIntError tipas reiškia klaidas, atsirandančias iš eilės į sveikąjį skaičių analizės operacijos.
• The std:: parinktis:: NoneError tipas reiškia klaidas išpakavus tuščias parinktis.
• The std:: rezultatas:: Rezultatas tipas yra bendras rezultato tipas, kurį galite naudoti bet kokiai klaidai pavaizduoti.

Kiekvienas klaidos tipas turi savo metodų ir bruožų rinkinį, skirtą jai valdyti konkrečiais būdais.

Štai failo skaitymo operacijos „Rust“ klaidų apdorojimo pavyzdys:

naudoti std:: fs:: Failas;
naudoti std:: io:: Skaityti;
fnskaitymo_failas(kelias: &g) -> Rezultatas<Styga, std:: io:: Klaida> {
leistimut file = Failas:: atidaryti (kelias)?;
leistimut turinys = Styga::naujas();
 file.read_to_string(&mut turinys)?;
Gerai(turinys)
}

The skaitymo_failas funkcija nuskaito failo turinį nurodytame kelyje ir grąžina jį kaip eilutę. Tai grąžina a std:: io:: Klaida jei failo atidarymo arba skaitymo operacija nepavyksta. The ? operatorius išplatina klaidą ir pateikia klaidą kaip a Rezultatas.

Klaidų apdorojimo mechanizmai rūdyje

Viena iš pagrindinių savybių, prisidedančių prie „Rust“ saugumo, yra klaidų valdymo mechanizmai. „Rust“ yra keturi pagrindiniai klaidų valdymo mechanizmai: „ Rezultatas tipas, Parinktis tipas, panika! makrokomandą ir Klaida bruožas.

Rezultatų ir parinkčių tipai leidžia struktūriškai tvarkyti klaidas. Galite naudoti paniką! makrokomandą, skirtą nepataisomoms klaidoms tvarkyti. Klaidos bruožas leidžia apibrėžti pasirinktinius klaidų tipus ir pasirinktinį klaidų tvarkymą.

Rezultato tipas

The Rezultatas tipas yra integruotas tipas, nurodantis operacijos, kuri gali nepavykti, rezultatą. Jis turi du variantus: Gerai variantas, reiškiantis sėkmę ir turintis vertę, ir Err, kuris reiškia gedimą ir kuriame yra klaidos reikšmė.

Štai kaip galite naudoti rezultato tipą, kad atidarytumėte failą ir perskaitytumėte jo turinį:

naudoti std:: fs:: Failas;
naudoti std:: io:: preliudija::*;
fnskaitymo_failas(bylos kelias: &g) -> Rezultatas<Styga, std:: io:: Klaida> {
leistimut file = Failas:: atidaryti (failo_kelias)?;
leistimut turinys = Styga::naujas();
 file.read_to_string(&mut turinys)?;
Gerai(turinys)
}
fnpagrindinis() {
leisti rezultatas = read_file("failas.txt");
rungtynės rezultatas {
Gerai(turinys) => println!("{}", turinys),
Err(e) => println!("Klaida: {}", e),
 }
}

The skaitymo_failas funkcija paima failo kelią ir grąžina a Rezultatas klaida. Jei failo skaitymo arba atidarymo operacija nepavyksta, funkcija grąžina Err vertė. Kitu atveju funkcija grąžina Gerai vertė. Viduje pagrindinis funkcija, rungtynės pareiškimas tvarko Rezultatas reikšmę ir išspausdina rezultatą, priklausomai nuo failo operacijos situacijos.

Parinkties tipas

The Parinktis tipas yra įtaisytas tipas, nurodantis reikšmės buvimą arba nebuvimą. The Parinktis tipas turi du variantus. Kai kurie reiškia vertę ir Nė vienas reiškia vertės nebuvimą.

Štai kaip galite naudoti Parinktis tipo, kad gautumėte pirmąjį vektoriaus elementą.

fnget_first_elementKlonuoti> (vec: Sen) -> Parinktis {
jeigu vec.is_empty() {
Nė vienas
 } Kitas {
Kai kurie(vec.first().unwrap().clone())
 }
}
fnpagrindinis() {
leisti vec = vec![1, 2, 3];
leisti rezultatas = get_first_element (vec);
rungtynės rezultatas {
Kai kurie(elementas) => println!("{}", elementas),
Nė vienas => println!(„Vektorius tuščias“.),
 }
}

The get_first_element funkcija grąžina an Parinktis tipo. Jei vektorius tuščias, funkcija grąžinama Nė vienas; kitu atveju funkcija grąžinama Kai kurie kuriame yra pirmasis vektoriaus elementas. Viduje pagrindinis funkcija, rungtynės pareiškimas tvarko Parinktis vertė. Jei Parinktis vertina į Kai kurie, funkcija išspausdina pirmąjį elementą. Kitu atveju funkcija išspausdina pranešimą, nurodantį, kad vektorius tuščias.

Panika! Makro

The panika! makrokomanda suteikia galimybę tvarkyti neatstatomas Rust klaidas. Paskambinus į panika! makrokomandą, jis išspausdina klaidos pranešimą ir nutraukia programą.

Štai panikos naudojimo pavyzdys! makrokomandą, nurodydama, kad funkcija turi netinkamų argumentų.

fnpadalinti(dividendai: f64, daliklis: f64) -> f64 {
jeigu daliklis == 0.0 {
panika!("Dalytuvas negali būti nulis.");
 }
 dividendas / daliklis
}
fnpagrindinis() {
leisti rezultatas = padalinti (4.0, 0.0);
println!("{}", rezultatas);
}

The padalinti funkcija patikrina, ar daliklis lygus nuliui; jei daliklis lygus nuliui, funkcija iškviečia panika! makrokomandą su klaidos pranešimu; kitu atveju funkcija apskaičiuoja ir grąžina rezultatą

The pagrindinis funkcija iškviečia padalijimo funkciją su netinkamais argumentais, kad suaktyvintų panika! makrokomandą.

Štai klaidos pranešimas:

Klaidos bruožas

The Klaida bruožas yra įtaisytas bruožas, apibrėžiantis klaidų tipų elgesį. The Klaida ypatybė suteikia galimybę apibrėžti pasirinktinius klaidų tipus ir pasirinktines klaidas.

Pateikiame tinkinto klaidos tipo apibrėžimo, nurodančio failo nerasta klaidą, pavyzdys.

naudoti std:: klaida:: Klaida;
naudoti std:: fmt;
naudoti std:: io:: Skaityti;
#[išvesti (derinti)]
struktūraFailas nerastas(Styga);
impl fmt:: Ekranas dėl Failas nerastas {
fnfmt(&savarankiškai, f: &mut fmt:: Formatuotojas) -> fmt::Rezultatas {
parašyk!(f, "Failas nerastas: {}", savarankiškai.0)
 }
}
impl Klaida dėl Failas nerastas {}
fnskaitymo_failas(bylos kelias: &g) -> Rezultatas<Styga, Dėžė<dyn Klaida>> {
leistimut failas = std:: fs:: Failas:: atidaryti (failo_kelias).map_err(|e| FileNotFound(formatu!("{}", e)))?;
leistimut turinys = Styga::naujas();
 file.read_to_string(&mut turinys)?;
Gerai(turinys)
}
fnpagrindinis() {
leisti rezultatas = read_file("failas.txt");
rungtynės rezultatas {
Gerai(turinys) => println!("{}", turinys),
Err(e) => println!("Klaida: {}", e),
 }
}

Pasirinktinis klaidos tipas yra Failas nerastas struktūra. Tipe yra failo kelias ir Failas nerastas tipas įgyvendina Ekranas savybė grąžinti patogius klaidų pranešimus ir Klaida bruožas, rodantis, kad tai klaidos tipas.

Viduje skaitymo_failas funkcija, Failas nerastas klaidos tipas reiškia failo nerasta klaidą, o map_err metodas konvertuoja std:: io:: klaidą į FileNotFound klaidą. Pagaliau, dėžė tipas leidžia funkcijai grąžinti bet kokį tipą, kuris įgyvendina klaidos požymį.

The pagrindinis funkcija iškviečia skaitymo_failas funkcija su failo keliu ir, radusi failą, išspausdina jo turinį į konsolę. Priešingu atveju jis išspausdins klaidos pranešimą.

Štai failo, kurio nėra, rezultatas:

Galite remtis „Rust“ nuosavybės modeliu, kad užtikrintumėte programos saugumą

Kartu su nuostabiu „Rust“ klaidų valdymo mechanizmu „Rust“ taip pat naudoja nuosavybės modelį, kuris padeda užtikrinti, kad jūsų programos būtų saugios atmintyje.

Rust užtikrina nuosavybės taisykles su skolinimosi tikrintuvu kompiliavimo metu prieš paleidžiant programą.