Convertir une chaîne en int dans Rust?

Remarque: cette question contient du code pré-1.0 obsolète! La réponse est cependant correcte.

Pour convertir un stren un intdans Rust, je peux faire ceci:

let my_int = from_str::<int>(my_str);

La seule façon de savoir comment convertir un Stringen un intest d'en obtenir une tranche et de l'utiliser from_strcomme ceci:

let my_int = from_str::<int>(my_string.as_slice());

Existe-t-il un moyen de convertir directement un Stringen un int?

Vous pouvez directement convertir en un entier en utilisant la str::parse::<T>()méthode .

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, soit via une annotation de type explicite:

let my_int: i32 = my_string.parse().unwrap();

Comme mentionné dans les commentaires, parse()renvoie un fichier Result. Ce résultat sera un Errsi la chaîne n'a pas pu être analysée comme le type spécifié (par exemple, la chaîne "peter"ne peut pas être analysée comme 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(),
}

str::parse::<u32>renvoie a Result<u32, core::num::ParseIntError>et Result::unwrap"Développe un résultat, ce qui donne le contenu d'un Ok[ou] panique si la valeur est an Err, avec un message de panique fourni par la Errvaleur de."

str::parseest une fonction générique , d'où le type entre chevrons.

Si vous obtenez votre chaîne stdin().read_line, vous devez d'abord la couper.

let my_num: i32 = my_num.trim().parse()
   .expect("please give me correct string number!");

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 qu'il Stringpeut maintenant être déréférencé en un fichier str. Cependant, la fonction veut un &str, donc nous devons emprunter à nouveau. Pour référence, je crois que ce modèle particulier ( &*) est appelé «emprunt croisé».

Vous pouvez utiliser la méthode FromStrdu trait from_str, qui est implémentée pour i32:

let my_num = i32::from_str("9").unwrap_or(0);

Et bien non. Pourquoi devrait-il y en avoir? Jetez simplement la chaîne si vous n'en avez plus besoin.

&strest plus utile que Stringlorsque vous n'avez besoin de lire qu'une chaîne, car il ne s'agit que d'une vue de 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 appelées. À cet égard, c'est plus général: si vous avez un String, vous pouvez le passer à l'endroit où un &strest attendu, mais si vous l'avez &str, vous ne pouvez le passer qu'aux fonctions attendues Stringsi vous faites une nouvelle allocation.

Vous pouvez en savoir plus sur les différences entre ces deux et quand les utiliser dans le guide officiel des chaînes .

Donc, fondamentalement, vous voulez convertir une chaîne en un entier droit! voici ce que j'utilise le plus souvent et qui est également mentionné dans la documentation officielle ..

fn main() {

    let char = "23";
    let char : i32 = char.trim().parse().unwrap();
    println!("{}", char + 1);

}

Cela fonctionne à la fois pour String et & str J'espère que cela aidera aussi.