Remarque: cette question contient du code obsolète antérieur à la 1.0! La réponse est correcte, cependant.
Pour convertir une str
en une int
dans Rust, je peux le faire:
let my_int = from_str::<int>(my_str);
La seule façon pour moi de convertir une String
en une int
consiste à en obtenir une tranche, puis à utiliser from_str
comme suit:
let my_int = from_str::<int>(my_string.as_slice());
Existe-t-il un moyen de convertir directement une String
en une int
?
Vous pouvez convertir directement en un int en utilisant la méthode str::parse::<T>()
.
let my_string = "27".to_string(); // `parse()` works with `&str` and `String`!
let my_int = my_string.parse::<i32>().unwrap();
Vous pouvez soit spécifier le type à analyser avec l'opérateur turbofish (::<>
), comme indiqué ci-dessus, ou via une annotation de type explicite:
let my_int: i32 = my_string.parse().unwrap();
Comme mentionné dans les commentaires, parse()
renvoie un Result
. Ce résultat sera un Err
si la chaîne ne peut pas être analysée sous le type spécifié (par exemple, la chaîne "peter"
ne peut pas être analysée sous la forme i32
).
let my_u8: u8 = "42".parse::<u8>().unwrap();
let my_u32: u32 = "42".parse::<u32>().unwrap();
// or, to be safe, match the `Err`
match "foobar".parse::<i32>() {
Ok(n) => do_something_with(n),
Err(e) => weep_and_moan(),
}
parse
retourne un core::result::Result<u32, core::num::ParseIntError>
et unwrap
"déplace la valeur v hors de l'option s'il s'agit de Some (v) [ou] Panics si la valeur propre est égale à None".
parse
est une fonction générique , d'où le type entre crochets angulaires.
Avec une soirée récente, vous pouvez faire ceci:
let my_int = from_str::<int>(&*my_string);
Ce qui se passe ici, c'est que String
peut maintenant être déréférencé en un str
. Cependant, la fonction veut un &str
, nous devons donc emprunter à nouveau. Pour référence, je crois que ce modèle particulier (&*
) est appelé "emprunt croisé".
Et bien non. Pourquoi devrait-il y avoir? Il suffit de jeter la chaîne si vous n'en avez plus besoin.
&str
est plus utile que String
lorsque vous devez uniquement lire une chaîne, car il ne s'agit que d'une vue dans la donnée d'origine, pas de son propriétaire. Vous pouvez le transmettre plus facilement que String
, et il est copiable, il n'est donc pas consommé par les méthodes invoquées. À cet égard, il est plus général: si vous avez une String
, vous pouvez le transmettre là où un &str
est attendu, mais si vous avez &str
, vous ne pouvez le transmettre qu'aux fonctions attendant String
si vous faites une nouvelle allocation.
Vous pouvez trouver plus d'informations sur les différences entre ces deux applications et le moment de les utiliser dans le guide de chaînes official .
Vous pouvez utiliser la méthode from_str
du trait FromStr
, qui est implémentée pour i32
:
let my_num = i32::from_str("9").unwrap_or(0);
Si vous obtenez votre chaîne de stdin().read_line
, vous devez d'abord la couper.
let my_num: i32 = my_num.trim().parse()
.expect("please give me correct string number!");