Antwoord

Rust biedt handige standaardsystemen voor het converteren van strings naar getallen via de trait FromStr. De meest gebruikte methode is .parse::<T>(), die kan worden aangeroepen op strings en slices.

Achtergrond van de vraag

In veel programmeertalen is het converteren van een string naar een getal een gebruikelijke taak, maar in Rust wordt dit op de veiligste en transparantste manier gedaan; foutafhandeling maakt deel uit van het contract van de standaardbibliotheek en zijn geen runtime-excepties.

Probleem

.parse::<T>() retourneert een resultaat van het type Result<T, ParseIntError> (of vergelijkbaar voor andere types), wat je dwingt om mislukkingen expliciet te behandelen. Een veelgemaakte fout is om de mogelijkheid van een fout te negeren en unwrap() te gebruiken zonder analyse, wat kan leiden tot een crash van het programma bij onjuiste invoer in plaats van een correcte foutmelding.

Oplossing

Voor de conversie van strings wordt de methode parse gebruikt. De handtekening is:

let num: i32 = "42".parse().unwrap();

Maar het is beter om de fout te verwerken:

let s = "abc";
match s.parse::<i32>() {
    Ok(n) => println!("Ontvangen nummer: {}", n),
    Err(e) => println!("Fout bij parsing: {e}"),
}

Belangrijke kenmerken:

Voor elk numeriek type is FromStr geïmplementeerd, maar de exacte beperkingen zijn impliciet: spaties, tekens, en overloop worden verschillend behandeld.
Fouten worden geretourneerd als Result, niet via paniek of uitzonderingen.
Elk type met een implementatie van FromStr (inclusief gebruikersgedefinieerde types) kan het doel zijn van .parse().

Lastige vragen.

Kan ik parse gebruiken zonder het resultaat-type aan te geven?

Nee, zonder het type te specificeren (of impliciete type-inferentie) zal Rust een foutmelding geven omdat het niet begrijpt naar welk type het moet converteren.

Wat gebeurt er als ik probeer een string met niet-numerieke inhoud naar een getal te parseren?

De methode retourneert een fout (Err(...)), er zal geen paniek ontstaan. De fout implementeert de trait Debug, wat handig is voor uitvoer.

let num: Result<u32, _> = "not_a_number".parse();
assert!(num.is_err());

Kan ik unwrap gebruiken na parse, als ik zeker ben van de inhoud?

Technisch gezien kan het, maar het is een anti-patroon. Als de string onverwacht ongeldig is, zal het programma crashen.

Typische fouten en anti-patronen

Gebruik van unwrap() zonder foutafhandeling
Niet gebruiken van trim voor conversie als de invoer van de gebruiker komt
Typefout bij parse (parse::<String>()) in plaats van het doelnumerieke type

Voorbeeld uit het leven

Negatieve case

Een console-tool leest een nummer van de gebruiker en gebruikt .parse().unwrap(). Bij onbedoelde onjuiste invoer crasht het programma onverwachts, de gebruiker begrijpt de reden niet.

Voordelen:

Eenvoudigere code

Nadelen:

Potentiële crash van het programma, slecht gebruikerservaring

Positieve case

De invoer wordt eerst ontdaan van spaties, en parse wordt gebruikt in een match-scenario of indien nodig — map_err voor het retourneren van een eigen fout. Fouten worden correct afgehandeld en er wordt een duidelijke foutmelding gegeven.