Gibt es eine weniger ausführliche Möglichkeit, eine Standardzeichenfolge aus einem Vektor von Zeichenfolgen abzurufen?

Question

Ich habe versucht mit &str anstelle von String, aber das hat Kompilierungsfehler. Ich landete mit:

fn main() 
{ 
    let words: Vec<String> = vec!["apple".to_string(), "orange".to_string(), "banana".to_string()]; 
    let word: String = match words.get(4) 
    { 
     Some(s) => s.to_string() 
     , None => "nil".to_string() 
    }; 
    println!("word: {}", word); 
} 

Answer 1

Es gibt zwei Dinge, die sofort dieses Programm verkürzen helfen:

1. Typ Folgerung: Sie sehr selten Arten aus
2. &str schreiben müssen: viel zu viele Anrufe to_string hier

Ich würde es als schreiben:

fn main() { 
    let words = vec!["apple", "orange", "banana"]; 
    let word = match words.get(4) { 
     Some(&s) => s, 
     None => "nil" 
    }; 
    println!("word: {}", word); 
} 

Beachten Sie, dass Vec<T>::get eine Option<&T> zurückgibt, also hier eine Option<&&str>, da wir s vom Typ &str (einfach &) sein wollen, verwenden wir Some(&s) als Muster. Eine andere Option wäre Some(s) => *s, (hier s&&str zu sein und es zu dereferenzieren).

Natürlich kann dies alles noch weiter reduziert werden, indem man sich die spezifische API von Option ansieht. Etwas weniger universell, aber Option und Result werden sehr oft in Rust verwendet (so sehr sind sie im Vorspiel !!!) und deshalb lohnt es sich, ihre APIs zu lernen.

In diesem Fall unwrap_or entweder den Wert innerhalb Option oder den ihm übergebenen Wert liefern:

fn main() { 
    let words = vec!["apple", "orange", "banana"]; 
    let word = *words.get(4).unwrap_or(&"nil"); 
    println!("word: {}", word); 
} 

Bit Referenz Jonglieren die Typen auf Line-up (auch bekannt als Typ Tetris) und es ist alles gut.

Answer 2

Es ist wichtig, dass die Zwangsregeln strings zu erinnern, wenn zwischen &str und String entscheiden.

fn main() 
{ 
    let words = vec!["apple", "orange", "banana"]; // Vec<&str> 
    let word = match words.get(2) {    // &str 
     Some(&s) => s 
     None => "nil" 
    }; 
    println!("word: {}", word); 
} 

Sie konnten den words und word passenden Code konsolidieren, wenn die Länge für Sie immer noch ein Problem ist, aber ich denke, das (vielleicht einschließlich Typenannotationen) ohne Kompromisse Klarheit der prägnanteste ist.

Answer 3

Ich bin nicht ganz sicher, was Sie erreichen wollen, aber das ist wahrscheinlich der beste Weg, genau das zu tun, was Sie in Ihrem Code haben:

fn main() { 
    let words = vec!["apple", "orange", "banana"]; 
    let word = words.get(4).cloned().unwrap_or("nil").to_string(); 
    println!("word: {}", word); 
} 

Der schwierige Teil ist cloned(): die get() Methode gibt einen optionalen Verweis auf den Wert innerhalb des Vektors zurück. Aber da der Vektor bereits Referenzen enthält, enden wir mit Option<&&str> (zwei Referenzen). Der Aufruf cloned() entfernt eine Referenz, also haben wir Option<&str>.

Beachten Sie auch, dass in diesem Beispiel der letzte Aufruf to_string() nicht erforderlich ist - wir können alles nur mit &str tun.