ParseIntError în Rust

use std::num::{IntErrorKind, ParseIntError};

fn kind(&self) -> &IntErrorKind

Ce face ParseIntError

"42".parse::<i32>() și i32::from_str_radix returnează Result<i32, ParseIntError>. Eroarea are un mesaj pentru oameni (prin Display) și un motiv exact, aflat cu kind().

Motivele posibile (IntErrorKind): Empty (text gol), InvalidDigit (caracter care nu e cifră, inclusiv spații), PosOverflow (număr prea mare pentru tip), NegOverflow (prea mic), Zero (doar pentru tipurile NonZero).

Pentru numere zecimale, eroarea este ParseFloatError, care nu are kind() public.

Ce returnează

kind() returnează &IntErrorKind.

Exemple

Exemplul 1: Mesajele și motivele

Spațiile nu sunt acceptate de parse: " 7" dă InvalidDigit. De aceea se scrie de obicei text.trim().parse().

fn main() {
    for t in ["", "12a", " 7", "300", "-200"] {
        match t.parse::<i8>() {
            Ok(n) => println!("{t:?} -> {n}"),
            Err(e) => println!("{t:?} -> {e}  ({:?})", e.kind()),
        }
    }
}

Rezultat

"" -> cannot parse integer from empty string  (Empty)
"12a" -> invalid digit found in string  (InvalidDigit)
" 7" -> invalid digit found in string  (InvalidDigit)
"300" -> number too large to fit in target type  (PosOverflow)
"-200" -> number too small to fit in target type  (NegOverflow)

Exemplul 2: Mesaj diferit după motiv

use std::num::IntErrorKind;

fn mesaj(text: &str) -> String {
    match text.trim().parse::<u8>() {
        Ok(n) => format!("ai introdus {n}"),
        Err(e) => match e.kind() {
            IntErrorKind::Empty => String::from("nu ai scris nimic"),
            IntErrorKind::InvalidDigit => format!("„{text}” conține caractere care nu sunt cifre"),
            IntErrorKind::PosOverflow => String::from("numărul este prea mare (maxim 255)"),
            _ => format!("eroare: {e}"),
        },
    }
}

fn main() {
    for t in ["42", "", "4 2", "1000"] {
        println!("{}", mesaj(t));
    }
}

Rezultat

ai introdus 42
nu ai scris nimic
„4 2” conține caractere care nu sunt cifre
numărul este prea mare (maxim 255)

Greșeli frecvente

• Uiți trim() la textul citit de la tastatură: linia conține și \n, deci parse dă InvalidDigit.
• Parsezi în u32 un text cu minus: "-5".parse::<u32>() dă InvalidDigit, nu NegOverflow.

Comenzi înrudite

• Result: Tipul pentru operații care pot eșua: Ok(valoare) la succes sau Err(eroare) cu motivul eșecului.
• i32::from_str_radix: Transformă un text în număr într-o bază aleasă (2 = binar, 16 = hexazecimal etc.).
• Error: Trait-ul comun al tuturor tipurilor de eroare: o eroare se poate afișa (Display, Debug) și poate avea o cauză.
• Infallible: Tipul de eroare pentru operații care nu pot eșua niciodată: un enum fără variante, deci fără nicio valoare posibilă.