Wie kann man einen String mit String-Literalen abgleichen?

Question

Ich versuche herauszufinden, wie man in Rust einen String matcht.

Ich habe zunächst versucht, so zu matchen, aber ich habe festgestellt, dass Rust nicht implizit von std::string::String zu &str casten kann.

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

Dies hat den Fehler:

Fehler[E0308]: fehlanpassende Typen
 --> src/main.rs:4:9
  |
4 |         "a" => println!("0"),
  |         ^^^ erwarteter Typ `std::string::String`, gefunden Referenz
  |
  = Hinweis: erwarteter Typ `std::string::String`
             gefundener Typ `&'static str`

Dann habe ich versucht, neue String-Objekte zu konstruieren, da ich keine Funktion gefunden habe, um einen String in einen &str zu casten.

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 hat mir den folgenden Fehler 3 Mal gegeben:

Fehler[E0164]: `String::from` benennt keine Tuple-Variante oder ein Tuple-Strukt
 --> src/main.rs:4:9
  |
4 |         String::from("a") => return 0,
  |         ^^^^^^^^^^^^^^^^^ keine Tuple-Variante oder Struktur

Wie matched man in Rust tatsächlich Strings?

Answer 1

UPDATE: Verwenden Sie .as_str() so, um den String in ein &str umzuwandeln:

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

Grund .as_str() ist prägnanter und erzwingt eine strengere Typüberprüfung. Das Trait as_ref ist für mehrere Typen implementiert und sein Verhalten könnte für den Typ String geändert werden, was zu unerwarteten Ergebnissen führen kann. Ebenso wird der Compiler kein Problem melden, wenn das Eingabeargument den Typ ändert, aber dieser Typ das Trait as_ref implementiert.

Die Dokumentation empfiehlt auch die Verwendung von as_str unter https://doc.rust-lang.org/std/string/struct.String.html, https://doc.rust-lang.org/std/primitive.str.html

Alte Antwort:

as_slice ist veraltet, Sie sollten stattdessen das Trait std::convert::AsRef verwenden:

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

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

Answer 2

Sie können so etwas machen:

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

Seit Rust 1.7.0 gibt es auch eine as_str Methode:

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

Answer 3

Sie könnten auch Folgendes tun

übereinstimmen &stringthing als &str {
    "a" => println!("0"),
    "b" => println!("1"),
    "c" => println!("2"),
    _ => println!("etwas anderes!"),
}

Siehe:

• std::string::String
• std::ops::Deref
• Deref coercions

Answer 4

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

Sie können auf ein String-Slice matchen.

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

Answer 5

Sie können den String mithilfe der Methode as_str() in ein &str konvertieren und dann auf den &str-Wert übereinstellen, wie folgt:

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

Oder Sie können den String-Wert einer Variablen zuordnen und dann wie folgt auf die Variable übereinstellen:

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

Oder Sie können den == Operator verwenden, um den String-Wert mit einem String-Literal zu vergleichen, wie folgt:

fn main() {
    let stringthing = String::from("c");
    if stringthing == "a" {
        println!("0");
    } else if stringthing == "b" {
        println!("1");
    } else if stringthing == "c" {
        println!("2");
    } else {
        println!("other");
    }
}