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

Sie können es versuchen:

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

Answer 2

Sie können den String in &str umwandeln, indem Sie dies tun:

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

Answer 3

In Rust kannst du in der Regel keine String direkt in einer match-Anweisung verwenden, weil String ein dynamischer, heap-allocierter Datentyp ist und match Werte mit einem bekannten und festen Satz von Möglichkeiten zur Kompilierzeit erwartet.

Du kannst jedoch eine String in einer match-Anweisung verwenden, indem du sie zuerst mit der Methode as_str() in ein &str umwandelst oder durch Verwendung von Pattern-Matching mit einem Verweis auf die String.

match erwartet erschöpfende und bekannte Muster: Der match-Ausdruck erfordert, dass du alle möglichen Muster zur Kompilierzeit spezifizierst. String-Literale sind zur Kompilierzeit bekannt, sodass du sie direkt in einem match verwenden kannst. Andererseits wird der Inhalt eines String zur Laufzeit bestimmt und kann variieren, daher kann er nicht direkt in einem match verwendet werden.

Answer 4

Wie andere Antworten bereits gezeigt haben, ist String nicht str. Also im Grunde wird jede Funktion, die in ein str konvertieren kann, funktionieren. Als ich etwas über die Befehlszeile eingelesen habe, fand ich besonders nützlich die trim() Methode (um die neue Zeile loszuwerden und ein str zurückzugeben). Wie in den Kommentaren erwähnt, führt es automatisch eine Dereferenzierung während des Aufrufs durch.

Hier ist der Code, den ich benutzt habe:

let mut input: String = Default::default();
io::stdin().read_line(&mut input)
           .expect("Etwas Schlimmes ist passiert");
match input.trim() {
    "a" => println!("0"),
    "b" => println!("1"),
    "c" => println!("2"),
    _ => println!("etwas anderes!"),
}

Answer 5

Verwenden Sie as_str() auf Strings, um einen Zeichenfolgenschnitt zu erhalten

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

Wenn Sie Eingaben von der Konsole erhalten und darauf ein Matching durchführen möchten, stellen Sie sicher, dass Sie nach as_str() trim() aufrufen, um das Escape-Zeichen d.h. '\n' aus der Eingabe zu entfernen. Wie folgt

match stringthing.as_str().trim() {...}