`str::parse` în Rust

Transformă textul într-o altă valoare (număr, bool, char, IP, tip propriu) și returnează Result.

Sintaxă

pub fn parse<F: FromStr>(&self) -> Result<F, F::Err>

Ce face `str::parse`

parse citește textul și încearcă să-l transforme în tipul cerut. Tipul se dă fie la variabilă (let n: i32 = s.parse()?), fie cu „turbofish” (s.parse::<f64>()). Funcționează pentru orice tip care implementează FromStr: toate numerele, bool, char, String, adrese IP și tipurile tale.

Rezultatul este un Result: Ok(valoare) sau Err cu motivul. Textul nu trebuie să conțină spații în plus (aplică trim()), iar numerele zecimale folosesc punct, nu virgulă: "4,50" nu este un f64 valid.

Ce returnează

Result<F, F::Err>; pentru numere eroarea este ParseIntError sau ParseFloatError.

Exemple

Exemplul 1: Numere, bool și erori

fn main() {
    let a: i32 = "-17".parse().unwrap();
    let b = "3.75".parse::<f64>().unwrap();
    let c: bool = "true".parse().unwrap();
    println!("{a} {b} {c}");

    println!("{:?}", "12a".parse::<i32>());
    println!("{:?}", "".parse::<u8>());
    println!("{:?}", "300".parse::<u8>());
    println!("{:?}", "4,50".parse::<f64>());
    println!("{:?}", " 7".parse::<i32>());
}

Rezultat

-17 3.75 true
Err(ParseIntError { kind: InvalidDigit })
Err(ParseIntError { kind: Empty })
Err(ParseIntError { kind: PosOverflow })
Err(ParseFloatError { kind: Invalid })
Err(ParseIntError { kind: InvalidDigit })

Exemplul 2: Mesaje prietenoase pentru erori

fn pret(text: &str) -> Result<f64, String> {
    let curat = text.trim().replace(',', ".");
    curat.parse::<f64>().map_err(|e| format!("„{text}” nu este un preț valid ({e})"))
}

fn main() {
    for t in ["12,50", " 7 ", "zece"] {
        match pret(t) {
            Ok(p) => println!("preț: {p:.2} lei"),
            Err(e) => println!("eroare: {e}"),
        }
    }
}