Wie kann man einen String mit String-Literalen in Rust abgleichen?

Ich versuche herauszufinden, wie man einen Stringin Rust zusammenbringt.

Ich habe anfangs versucht, so zu passen, aber ich habe herausgefunden, dass Rust nicht implizit von std::string::Stringbis werfen kann &str.

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

Dies hat den Fehler:

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`

Ich habe dann versucht , neu zu konstruieren StringObjekte, da ich keine Funktion werfen einen finden konnte Stringzu ein &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"),
    }
}

Dies gab mir dreimal den folgenden Fehler:

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

Wie passt man eigentlich zu Strings in Rust?

Sie können so etwas tun:

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

as_strAb Rust 1.7.0 gibt es auch eine Methode:

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

as_sliceveraltet ist, sollten Sie jetzt std::convert::AsRefstattdessen das Merkmal verwenden:

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

Beachten Sie, dass Sie auch den Sammelfall explizit behandeln müssen.

Sie könnten auch tun

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

Sehen:

• std::string::String
• std::ops::Deref
• Deref Zwänge

Anmerkung des Herausgebers: Diese Antwort bezieht sich auf eine Version von Rust vor 1.0 und funktioniert nicht in Rust 1.0

Sie können auf einem String-Slice übereinstimmen.

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

Du kannst es versuchen:

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