Was ist in Rust unwrap und wofür wird es verwendet?

Question

Ich habe diesen Code, .unwrap() verwendet:

fn main() { 
    let paths = std::fs::read_dir("/home/user").unwrap(); 

    for path in paths { 
     println!("Name: {}", path.unwrap().path().display()); 

    } 
} 

,

pub fn unwrap(self) -> T { 
    match self { 
     Ok(t) => t, 
     Err(e) => unwrap_failed("called `Result::unwrap()` on an `Err` value", e), 
    } 
} 

am definition of unwrap Nach einem Blick und die signature of read_dir

pub fn read_dir<P: AsRef<Path>>(path: P) -> io::Result<ReadDir> 

Bin ich Verständnis richtig, dass unwrap die T zurück Typ, der inübergeben wird?

Answer 1

In Rust, wenn Sie eine Operation haben, die entweder eine T oder nicht zurückkehren können, erhalten Sie einen Wert vom Typ haben Result<T,E> oder Option<T> (E wird der Fehlerzustand bei einem interessanten Fehler sein).

Die Funktion unwrap(self) -> T gibt Ihnen die eingebettete T, wenn es eine gibt. Wenn stattdessen kein T sondern ein E oder None ist, wird es in Panik geraten.

Es wird am besten verwendet, wenn Sie sicher sind, dass Sie keinen Fehler haben. Wenn dies nicht der Fall ist, ist es normalerweise besser, entweder den Fehler mit dem Muster zu vergleichen oder das Makro try! zu verwenden, um den Fehler weiterzuleiten.

In Ihrem Beispiel gibt der Aufruf an read_dir() eine io::Result<ReadDir> zurück, da das Öffnen des Verzeichnisses fehlschlagen kann. Und das wiederholte Iterieren des geöffneten Verzeichnisses gibt mehrere Werte vom Typ zurück, da das Lesen des Verzeichnisses möglicherweise ebenfalls fehlschlägt.

Mit try! wäre es so etwas wie dieses:

fn main2() -> std::io::Result<()> { 
    let paths = try!(std::fs::read_dir("/home/user")); 

    for path in paths { 
     println!("Name: {}", try!(path).path().display()); 

    } 
    Ok(()) 
} 

fn main() { 
    let res = main2(); 

    if let Err(e) = res { 
     println!("Error: {}", e); 
    } 
} 

Sehen Sie, wie jeder Fehlerfall geprüft wird.