Rješavanje pogrešaka u Rustu različitim pristupima

Pogreške su neizbježne i mogu se pojaviti iz različitih razloga, od nevažećih korisničkih unosa do kvarova na mreži, kvarova hardvera ili programskih grešaka. Rješavanje pogrešaka je proces otkrivanja, izvješćivanja i oporavka od takvih pogrešaka kako bi se spriječilo rušenje programa ili oštećenje podataka.

Učinkovito rukovanje pogreškama ključno je u Rustu. Omogućuje vam stvaranje robusnih, pouzdanih aplikacija koje se mogu nositi s neočekivanim pogreškama i kvarovima. Rustovi mehanizmi za rukovanje pogreškama omogućuju vam da razvijete otporne, sigurne programe koje je lakše održavati.

Vrste pogrešaka u Rustu

Rust ima bogat sustav tipova koji možete koristiti vješto rješavati pogreške, prema njihovim vrstama. Prednosti Rustovog bogatog sustava tipa pogrešaka u odnosu na tradicionalne pristupe rukovanju greškama ne mogu se podcijeniti. Sustav vrste pogreške pruža poboljšana sigurnost tipa, skladnost, izražajnost i mogućnost otklanjanja pogrešaka.

Evo popisa uobičajenih vrsta pogrešaka u Rustu:

• The std:: io:: Greška vrsta predstavlja I/O pogreške kao što je datoteka nije pronađena, dopuštenje odbijeno ili dosegnut kraj datoteke.
• The std:: num:: ParseIntError tip predstavlja pogreške koje se javljaju u operacijama raščlambe niza u cijeli broj.
• The std:: opcija:: NoneError vrsta predstavlja pogreške od odmatanja praznih opcija.
• The std:: rezultat:: Rezultat tip je generički tip rezultata koji možete koristiti za predstavljanje svake pogreške.

Svaka vrsta pogreške ima vlastiti skup metoda i značajki za rukovanje njome na određene načine.

Evo primjera rukovanja pogreškama u Rustu za operaciju čitanja datoteke:

koristiti std:: fs:: Datoteka;
koristiti std:: io:: Read;
fnread_file(staza: &str) -> Proizlaziti<Niz, std:: io:: Greška> {
nekamut file = File:: open (staza)?;
nekamut sadržaj = Niz::novi();
 file.read_to_string(&mut sadržaj)?;
U redu(sadržaj)
}

The read_file funkcija čita sadržaj datoteke na navedenoj stazi i vraća ga kao niz. Vraća a std:: io:: Greška ako operacija otvaranja ili čitanja datoteke ne uspije. The ? operator širi pogrešku i vraća je kao a Proizlaziti.

Mehanizmi za rukovanje pogreškama u Rustu

Jedna ključna značajka koja pridonosi sigurnosti Rusta su njegovi mehanizmi za obradu grešaka. U Rustu postoje četiri glavna mehanizma za rukovanje pogreškama: Proizlaziti vrsta, Opcija vrsta, panika! makro, i Greška osobina.

Tipovi Result i Option omogućuju strukturirano rukovanje pogreškama. Možete iskoristiti paniku! makro za obradu nepopravljivih pogrešaka. Značajka pogreške omogućuje vam definiranje prilagođenih vrsta pogrešaka i prilagođenog rukovanja pogreškama.

Vrsta rezultata

The Proizlaziti type je ugrađeni tip koji predstavlja rezultat operacije koja može biti neuspješna. Ima dvije varijante: U redu varijanta, koja predstavlja uspjeh i sadrži vrijednost, i Err, što predstavlja neuspjeh i sadrži vrijednost pogreške.

Evo kako možete koristiti vrstu rezultata za otvaranje datoteke i čitanje njezinog sadržaja:

koristiti std:: fs:: Datoteka;
koristiti std:: io:: preludij::*;
fnread_file(put_datoteke: &str) -> Proizlaziti<Niz, std:: io:: Greška> {
nekamut datoteka = datoteka:: otvori (staza_datoteke)?;
nekamut sadržaj = Niz::novi();
 file.read_to_string(&mut sadržaj)?;
U redu(sadržaj)
}
fnglavni() {
neka rezultat = read_file("datoteka.txt");
odgovarati rezultat {
U redu(sadržaj) => println!("{}", sadržaj),
Err(e) => println!("Pogreška: {}", e),
 }
}

The read_file funkcija uzima put datoteke i vraća a Proizlaziti greška. Ako operacija čitanja ili otvaranja datoteke ne uspije, funkcija vraća Err vrijednost. U suprotnom, funkcija vraća U redu vrijednost. u glavni funkcija, odgovarati izjava obrađuje Proizlaziti vrijednost i ispisuje rezultat ovisno o situaciji operacije datoteke.

Vrsta opcije

The Opcija type je ugrađeni tip koji predstavlja prisutnost ili odsutnost vrijednosti. The Opcija tip ima dvije varijante. Neki predstavlja vrijednost, i Nijedan predstavlja odsustvo vrijednosti.

Evo kako možete koristiti Opcija tip za dohvaćanje prvog elementa vektora.

fndobiti_prvi_elementKlon>(vec: Vec) -> Opcija {
ako vec.is_empty() {
Nijedan
 } drugo {
Neki(vec.first().unwrap().clone())
 }
}
fnglavni() {
neka vec = vec![1, 2, 3];
neka rezultat = get_prvi_element (vec);
odgovarati rezultat {
Neki(element) => println!("{}", element),
Nijedan => println!("Vektor je prazan."),
 }
}

The dobiti_prvi_element funkcija vraća an Opcija tip. Ako je vektor prazan, funkcija se vraća Nijedan; inače, funkcija se vraća Neki koji sadrži prvi element vektora. u glavni funkcija, odgovarati izjava obrađuje Opcija vrijednost. Ako je Opcija procjenjuje na Neki, funkcija ispisuje prvi element. U suprotnom, funkcija ispisuje poruku koja pokazuje da je vektor prazan.

Panika! Makro

The panika! makro pruža funkcionalnost za rukovanje nepopravljivim pogreškama u Rustu. Na poziv panika! makro, ispisuje poruku o pogrešci i prekida program.

Evo primjera korištenja panike! makro za označavanje da funkcija ima nevažeće argumente.

fnpodijeliti(dividenda: f64, djelitelj: f64) -> f64 {
ako djelitelj == 0.0 {
panika!("Djeljenik ne može biti nula.");
 }
 dividenda / djelitelj
}
fnglavni() {
neka rezultat = podijeli(4.0, 0.0);
println!("{}", rezultat);
}

The podijeliti funkcija provjerava je li djelitelj nula; ako je djelitelj nula, funkcija poziva panika! makro s porukom o pogrešci; inače, funkcija izračunava i vraća rezultat

The glavni funkcija poziva funkciju dijeljenja s nevažećim argumentima za pokretanje panika! makro.

Evo poruke pogreške:

Osobina pogreške

The Greška značajka je ugrađena značajka koja definira ponašanje tipova pogrešaka. The Greška trait pruža funkcionalnost za definiranje prilagođenih vrsta pogrešaka i prilagođeno rukovanje pogreškama.

Evo primjera definiranja prilagođene vrste pogreške koja predstavlja pogrešku datoteka nije pronađena.

koristiti std:: error:: Error;
koristiti std:: fmt;
koristiti std:: io:: Read;
#[derive (debug)]
strukturiratiDatoteka nije pronađena(Niz);
impl fmt:: Prikaz za Datoteka nije pronađena {
fnfmt(&sebe, f: &mut fmt:: Formater) -> fmt::Proizlaziti {
pisati!(f, "Datoteka nije pronađena: {}", sebe.0)
 }
}
impl Greška za Datoteka nije pronađena {}
fnread_file(put_datoteke: &str) -> Proizlaziti<Niz, Kutija<din Greška>> {
nekamut datoteka = std:: fs:: datoteka:: otvori (put_datoteke).map_err(|e| FileNotFound(format!("{}", e)))?;
nekamut sadržaj = Niz::novi();
 file.read_to_string(&mut sadržaj)?;
U redu(sadržaj)
}
fnglavni() {
neka rezultat = read_file("datoteka.txt");
odgovarati rezultat {
U redu(sadržaj) => println!("{}", sadržaj),
Err(e) => println!("Pogreška: {}", e),
 }
}

Prilagođena vrsta pogreške je Datoteka nije pronađena strukturirati Tip sadrži put datoteke i Datoteka nije pronađena vrsta implementira Prikaz osobina vraćanja poruka o pogrešci koje su prilagođene korisniku i Greška značajka koja označava da je ovo vrsta pogreške.

u read_file funkcija, Datoteka nije pronađena tip greške predstavlja grešku da datoteka nije pronađena, a karta_greška metoda pretvara std:: io:: pogrešku u pogrešku FileNotFound. Konačno, kutija type omogućuje funkciji vraćanje bilo kojeg tipa koji implementira značajku Greška.

The glavni funkcija poziva read_file funkcionira s putanjom datoteke i, ako pronađe datoteku, ispisuje njezin sadržaj na konzolu. U suprotnom ispisuje poruku o pogrešci.

Evo rezultata za datoteku koja ne postoji:

Za sigurnost programa možete računati na Rustov model vlasništva

U kombinaciji s Rustovim veličanstvenim mehanizmom za rukovanje pogreškama, Rust također koristi model vlasništva koji pomaže osigurati da su vaši programi sigurni u memoriji.

Rust osigurava pravila vlasništva alatom za provjeru posuđivanja u vrijeme kompajliranja prije pokretanja vašeg programa.