Comment faire correspondre une chaîne avec des littéraux de chaîne dans Rust?

J'essaie de trouver un moyen de faire correspondre un Stringdans Rust.

J'ai d'abord essayé de faire des correspondances comme celle-ci, mais j'ai compris que Rust ne pouvait pas implicitement être casté de std::string::Stringà &str.

fn main() {
    let stringthing = String::from("c");
    match stringthing {
        "a" => println!("0"),
        "b" => println!("1"),
        "c" => println!("2"),
    }
}

Cela a l'erreur:

error[E0308]: mismatched types
 --> src/main.rs:4:9
  |
4 |         "a" => println!("0"),
  |         ^^^ expected struct `std::string::String`, found reference
  |
  = note: expected type `std::string::String`
             found type `&'static str`

J'ai ensuite essayé de construire de nouveaux Stringobjets, car je ne pouvais pas trouver de fonction pour convertir un Stringen un &str.

fn main() {
    let stringthing = String::from("c");
    match stringthing {
        String::from("a") => println!("0"),
        String::from("b") => println!("1"),
        String::from("c") => println!("2"),
    }
}

Cela m'a donné l'erreur suivante 3 fois:

error[E0164]: `String::from` does not name a tuple variant or a tuple struct
 --> src/main.rs:4:9
  |
4 |         String::from("a") => return 0,
  |         ^^^^^^^^^^^^^^^^^ not a tuple variant or struct

Comment faire correspondre les Strings à Rust?

Vous pouvez faire quelque chose comme ça:

match &stringthing[..] {
    "a" => println!("0"),
    "b" => println!("1"),
    "c" => println!("2"),
    _ => println!("something else!"),
}

Il existe également une as_strméthode à partir de Rust 1.7.0:

match stringthing.as_str() {
    "a" => println!("0"),
    "b" => println!("1"),
    "c" => println!("2"),
    _ => println!("something else!"),
}

as_sliceest obsolète, vous devez maintenant utiliser le trait à la std::convert::AsRefplace:

match stringthing.as_ref() {
    "a" => println!("0"),
    "b" => println!("1"),
    "c" => println!("2"),
    _ => println!("something else!"),
}

Notez que vous devez également gérer explicitement le cas fourre-tout.

Vous pourriez aussi faire

match &stringthing as &str {
    "a" => println!("0"),
    "b" => println!("1"),
    "c" => println!("2"),
    _ => println!("something else!"),
}

Voir:

• std::string::String
• std::ops::Deref
• Contraintes Deref

Note de l'éditeur: cette réponse concerne une version de Rust antérieure à 1.0 et ne fonctionne pas dans Rust 1.0

Vous pouvez faire correspondre sur une tranche de chaîne.

match stringthing.as_slice() {
    "a" => println!("0"),
    "b" => println!("1"),
    "c" => println!("2"),
    _ => println!("something else!"),
}

Tu peux essayer:

fn main() {
    let stringthing = String::from("c");
    match &*stringthing {
        "a" => println!("0"),
        "b" => println!("1"),
        "c" => println!("2"),
        _ => println!("else")
    }
}