Risposta

Rust fornisce mezzi standard convenienti per convertire stringhe in numeri attraverso il trait FromStr. Il metodo più comunemente utilizzato è .parse::<T>(), che può essere chiamato su stringhe e fette.

Storia della domanda

In molti linguaggi, la conversione di una stringa in un numero è un compito abituale, ma in Rust avviene in modo massimo sicuro e trasparente; gli errori di gestione fanno parte del contratto della libreria standard e non sono eccezioni di runtime.

Problema

.parse::<T>() restituisce un risultato di tipo Result<T, ParseIntError> (o simile per altri tipi), il che costringe a gestire esplicitamente i fallimenti. Un errore comune è ignorare la possibilità di errore, utilizzando unwrap() senza analisi, il che porta a un crash del programma in caso di input non valido, anziché a un messaggio di errore corretto.

Soluzione

Per convertire le stringhe si utilizza il metodo parse. La sua firma è:

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

Ma è più corretto gestire l'errore:

let s = "abc";
match s.parse::<i32>() {
    Ok(n) => println!("Numero ottenuto: {}", n),
    Err(e) => println!("Errore di parsing: {e}"),
}

Caratteristiche chiave:

Per ogni tipo numerico è implementato FromStr, ma le limitazioni esatte non sono evidenti: spazi, segni, overflow sono considerati in modo diverso
Gli errori vengono restituiti come Result, non tramite panico o eccezioni
Qualsiasi tipo con implementazione FromStr (inclusi quelli personalizzati) può essere obiettivo di .parse()

Domande con trabocchetto.

È possibile utilizzare parse senza specificare il tipo di risultato?

No, senza specificare il tipo (o l'inferenza di tipo implicita) Rust darà un errore, perché non capisce in quale tipo convertire.

Cosa succede se si cerca di parsare una stringa con contenuto non numerico in un numero?

Il metodo restituirà un errore (Err(...)), senza scatenare una panico. L'errore implementa il trait Debug, che è utile per la visualizzazione.

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

È possibile utilizzare unwrap dopo parse, se si è certi del contenuto?

Tecnicamente è possibile, ma è un anti-pattern. Se la stringa è inaspettatamente non valida, il programma terminerà in modo anomalo.

Errori comuni e anti-pattern

Uso di unwrap() senza gestione degli errori
Non utilizzo di trim prima della conversione, se l'input proviene dall'utente
Errore di tipo in parse (parse::<String>()) invece del tipo numerico target

Esempi dalla vita reale

Caso negativo

Un'utilità da console legge un numero dall'utente e utilizza .parse().unwrap(). In caso di un input errato casuale, il programma si interrompe improvvisamente e l'utente non capisce la causa.

Pro:

Codice più semplice

Contro:

Potenziale uscita dal programma, cattiva esperienza utente

Caso positivo

L'input viene inizialmente ripulito dagli spazi, e il parse è utilizzato in uno scenario con match o, se necessario, map_err per restituire il proprio errore. Gli errori vengono gestiti correttamente, fornendo un messaggio di errore chiaro.