Ruosteen aiheuttamien virheiden käsittely eri tavoilla

Virheet ovat väistämättömiä ja voivat johtua useista syistä virheellisestä käyttäjän syötöstä verkkoongelmiin, laitteiston toimintahäiriöihin tai ohjelmointivirheisiin. Virheenkäsittely on prosessi, jossa havaitaan, raportoidaan ja toiputaan tällaisista virheistä ohjelmien kaatumisen tai tietojen vioittumisen estämiseksi.

Tehokas virheiden käsittely on erittäin tärkeää Rustissa. Sen avulla voit luoda kestäviä, luotettavia sovelluksia, jotka voivat käsitellä odottamattomia virheitä ja epäonnistumisia. Rustin virheenkäsittelymekanismien avulla voit kehittää kestäviä, turvallisia ohjelmia, joita on helpompi ylläpitää.

Ruosteen virhetyypit

Rustissa on rikas tyyppinen järjestelmä, jota voit käyttää käsittelemään virheitä taitavastityyppien mukaan. Rustin rikkaan virhetyyppisen järjestelmän etuja perinteisiin virheenkäsittelymenetelmiin verrattuna ei voida aliarvioida. Virhetyyppijärjestelmä tarjoaa parannettu tyyppiturvallisuus, sommitettavuus, ilmaisukyky ja virheenkorjaus.

Tässä on luettelo ruosteen yleisistä virhetyypeistä:

• The std:: io:: Virhe tyyppi edustaa I/O-virheitä, kuten tiedostoa ei löydy, lupa estetty tai tiedoston loppu saavutettu.
• The std:: num:: ParseIntError tyyppi edustaa virheitä, jotka esiintyvät merkkijonosta kokonaislukujen jäsennystoimintoihin.
• The std:: option:: NoneError tyyppi edustaa virheitä tyhjien asetusten purkamisesta.
• The std:: tulos:: Tulos Type on yleinen tulostyyppi, jota voit käyttää edustamaan mitä tahansa virhettä.

Jokaisella virhetyypillä on omat menetelmänsä ja ominaisuutensa sen käsittelemiseksi tietyillä tavoilla.

Tässä on esimerkki virheiden käsittelystä Rustissa tiedostonlukutoiminnossa:

käyttää std:: fs:: Tiedosto;
käyttää std:: io:: Lue;
fnlue_tiedosto(polku: &str) -> Tulos<merkkijono, std:: io:: Virhe> {
antaamut file = Tiedosto:: avoin (polku)?;
antaamut sisältö = merkkijono::Uusi();
 file.read_to_string(&mut sisällys)?;
Ok(sisällys)
}

The lue_tiedosto funktio lukee määritetyn polun tiedoston sisällön ja palauttaa sen merkkijonona. Se palauttaa a std:: io:: Virhe jos tiedoston avaus- tai lukutoiminto epäonnistuu. The ? operaattori levittää virheen ja palauttaa virheen muodossa a Tulos.

Virheenkäsittelymekanismit ruosteessa

Yksi keskeinen ominaisuus, joka edistää Rustin turvallisuutta, on sen virheenkäsittelymekanismit. Rustissa on neljä pääasiallista virheenkäsittelymekanismia: the Tulos tyyppi, Vaihtoehto tyyppi, paniikki! makro ja Virhe piirre.

Tulos- ja Optio-tyypit mahdollistavat jäsennellyn virheenkäsittelyn. Paniikkia saa käyttää! makro korjaamattomien virheiden käsittelemiseksi. Virhe-ominaisuuden avulla voit määrittää mukautettuja virhetyyppejä ja mukautetun virheenkäsittelyn.

Tuloksen tyyppi

The Tulos Type on sisäänrakennettu tyyppi, joka edustaa toiminnon tulosta, joka voi epäonnistua. Siitä on kaksi muunnelmaa: Ok variantti, joka edustaa menestystä ja sisältää arvon, ja Err, joka edustaa epäonnistumista ja sisältää virhearvon.

Näin voit käyttää Tulostyyppiä tiedoston avaamiseen ja sen sisällön lukemiseen:

käyttää std:: fs:: Tiedosto;
käyttää std:: io:: alkusoitto::*;
fnlue_tiedosto(tiedostopolku: &str) -> Tulos<merkkijono, std:: io:: Virhe> {
antaamut file = Tiedosto:: auki (tiedoston_polku)?;
antaamut sisältö = merkkijono::Uusi();
 file.read_to_string(&mut sisällys)?;
Ok(sisällys)
}
fnpää() {
antaa tulos = read_file("tiedosto.txt");
ottelu tulos {
Ok(sisältö) => println!("{}", sisältö),
Err(e) => println!("Virhe: {}", e),
 }
}

The lue_tiedosto funktio ottaa tiedostopolun ja palauttaa a Tulos virhe. Jos tiedoston luku- tai avaamistoiminto epäonnistuu, funktio palauttaa Err arvo. Muussa tapauksessa funktio palauttaa Ok arvo. Vuonna pää toiminto, ottelu lausunto käsittelee Tulos arvo ja tulostaa tuloksen tiedoston toiminnan tilanteen mukaan.

Vaihtoehtotyyppi

The Vaihtoehto type on sisäänrakennettu tyyppi, joka edustaa arvon läsnäoloa tai puuttumista. The Vaihtoehto tyypistä on kaksi muunnelmaa. Jonkin verran edustaa arvoa ja Ei mitään edustaa arvon puuttumista.

Näin voit käyttää Vaihtoehto tyyppi noutaaksesi vektorin ensimmäisen elementin.

fnget_first_elementKlooni> (vec: Vec) -> Vaihtoehto {
jos vec.is_empty() {
Ei mitään
 } muu {
Jonkin verran(vec.first().unwrap().clone())
 }
}
fnpää() {
antaa vec = vec![1, 2, 3];
antaa tulos = get_first_element (vec);
ottelu tulos {
Jonkin verran(elementti) => println!("{}", elementti),
Ei mitään => println!("Vektori on tyhjä."),
 }
}

The get_first_element funktio palauttaa an Vaihtoehto tyyppi. Jos vektori on tyhjä, funktio palauttaa Ei mitään; muussa tapauksessa funktio palauttaa Jonkin verran sisältää vektorin ensimmäisen elementin. Vuonna pää toiminto, ottelu lausunto käsittelee Vaihtoehto arvo. Jos Vaihtoehto arvostelee Jonkin verran, funktio tulostaa ensimmäisen elementin. Muussa tapauksessa funktio tulostaa viestin, joka ilmoittaa, että vektori on tyhjä.

Paniikki! Makro

The paniikki! makro tarjoaa toiminnot korjaamattomien virheiden käsittelemiseen Rustissa. Soittaessaan paniikki! makro, se tulostaa virheilmoituksen ja lopettaa ohjelman.

Tässä on esimerkki paniikin käytöstä! makro osoittaa, että funktiolla on virheellisiä argumentteja.

fnjakaa(osinko: f64, jakaja: f64) -> f64 {
jos jakaja == 0.0 {
paniikki!("Jakaja ei voi olla nolla.");
 }
 osinko / jakaja
}
fnpää() {
antaa tulos = jakaa(4.0, 0.0);
println!("{}", tulos);
}

The jakaa funktio tarkistaa, onko jakaja nolla; jos jakaja on nolla, funktio kutsuu paniikki! makro virheilmoituksella; muussa tapauksessa funktio laskee ja palauttaa tuloksen

The pää -funktio kutsuu jako-funktiota virheellisillä argumenteilla käynnistääkseen funktion paniikki! makro.

Tässä on virheilmoitus:

Virhepiirre

The Virhe ominaisuus on sisäänrakennettu ominaisuus, joka määrittelee virhetyyppien käyttäytymisen. The Virhe ominaisuus tarjoaa toimintoja mukautettujen virhetyyppien ja mukautetun virheenkäsittelyn määrittämiseen.

Tässä on esimerkki mukautetun virhetyypin määrittämisestä, joka edustaa tiedostoa ei löydy -virhettä.

käyttää std:: error:: Error;
käyttää std:: fmt;
käyttää std:: io:: Lue;
#[derive (debug)]
structTiedostoa ei löytynyt(merkkijono);
impl fmt:: Näyttö varten Tiedostoa ei löytynyt {
fnfmt(&itse, f: &mut fmt:: Muotoilija) -> fmt::Tulos {
kirjoittaa!(f, "Tiedostoa ei löytynyt: {}", itse.0)
 }
}
impl Virhe varten Tiedostoa ei löytynyt {}
fnlue_tiedosto(tiedostopolku: &str) -> Tulos<merkkijono, Laatikko<dyn Virhe >> {
antaamut file = std:: fs:: Tiedosto:: open (file_path).map_err(|e| FileNotFound(muoto!("{}", e)))?;
antaamut sisältö = merkkijono::Uusi();
 file.read_to_string(&mut sisällys)?;
Ok(sisällys)
}
fnpää() {
antaa tulos = read_file("tiedosto.txt");
ottelu tulos {
Ok(sisältö) => println!("{}", sisältö),
Err(e) => println!("Virhe: {}", e),
 }
}

Mukautettu virhetyyppi on Tiedostoa ei löytynyt struct. Tyyppi sisältää tiedostopolun ja Tiedostoa ei löytynyt tyyppi toteuttaa Näyttö ominaisuus palauttaa käyttäjäystävällisiä virheilmoituksia ja Virhe ominaisuus, joka osoittaa, että tämä on virhetyyppi.

Vuonna lue_tiedosto toiminto, Tiedostoa ei löytynyt virhetyyppi edustaa tiedostoa ei löydy -virhettä, ja map_err menetelmä muuntaa std:: io:: -virheen FileNotFound-virheeksi. Lopuksi, laatikko type sallii funktion palauttaa minkä tahansa tyypin, joka toteuttaa Error-ominaisuuden.

The pää toiminto kutsuu lue_tiedosto funktion tiedostopolun kanssa ja, jos se löytää tiedoston, tulostaa sen sisällön konsoliin. Muussa tapauksessa se tulostaa virheilmoituksen.

Tässä on tulos tiedostolle, jota ei ole olemassa:

Voit panostaa Rustin omistusmalliin ohjelman turvallisuuden takaamiseksi

Yhdessä Rustin upean virheenkäsittelymekanismin kanssa Rust käyttää myös omistusmallia, joka auttaa varmistamaan, että ohjelmasi ovat muistiturvallisia.

Rust varmistaa omistussäännöt lainatarkistuksella käännöshetkellä ennen ohjelman suorittamista.