If you are absolutely sure that operation will succeed,you can use `unwrap`:
rust
let result : Result= Ok;老实说，let value = result.unwrap;按理说，println，;
从Output来看，rust
42
But if something goes wrong:
rust
let result : Result= Err;老实说，result.unwrap;// ← panic at runtime
Therefore:
* `unwrap` is great for quick prototyping or unit tests.
* It **should not** be used on data coming from user input or external systems.
`expect` 的用法与优点
`expect` 与 `unwrap` 类似，但可以提供自定义的错误信息：
rust
fn main {
let value =
"123".parse::
.expect;println，;}
如果解析失敗，程序会打印 `` 并 panic。相比 `unwrap`，它让定位问题更方便。---
`unwrap_or` 提供默认值
If you have a sensible fallback value:
rust
fn main {
let result : Result= Err;let value = result.unwrap_or;// 默认值
println!，// prints 10
}
`?` 运算符 – 自动传播错误
The most idiomatic way of propagating errors in Rust is `?` operator. It automatically returns early if an error occurs.
Example:
rust
use std::fs;fn read_file -> std::io::Result{
// `?` transforms inner type into ours.
let content = fs::read_to_string?，Ok
}
Without `?` it would look like this:
rust
use std::fs;fn read_file -> std::io::Result{
let res = fs::read_to_string;match res{
Ok=>Ok,Err=>Err,}
}
So `?` is just syntactic sugar that keeps your code readable.
Multiple-step error propagation
In real projects you often chain several operations that may fail:
rust
use std::fs;use std::num::ParseIntError;enum MyError {Io,Parse}
impl From for MyError{
fn from->Self{MyError::Io}
}
impl From::ParseIntError> for MyError{
fn from->Self{MyError::Parse}
}
fn calculate -> Result{
let txt = fs::read_to_string?，let number : i32 = txt.trim.parse?，Ok
}
Each step’s failure bubbles up automatically—no nested matches!
Converting Between Option & Result
Sometimes you need to convert 娱乐ween m:
From Result' to Option'
rust
let res : Result= Ok;let opt = res.ok;// Some
let err_res : Result= Err);let opt_none = err_res.ok;// None
From Option' to Result'
rust
let opt : Option= Some;let res_ok=opt.ok_or;// Ok
let none_opt: Option= None;let res_err=none_opt.ok_or;// Err
Custom Error Types
Using generic string errors quickly becomes unmanageable in large projects. Define your own error enums so callers know exactly what went wrong:
rust
enum AppError{
UserNotFound。InvalidPassword,Database,// wrap underlying db error message
}
fn login->Result<,AppError>{
if username.is_empty{
return Err;}
/* ，*/
Ok)
}
Now errors carry rich context without leaking implementation details.
实战案例
使用者注册校验
rust
enum RegisterErr{
EmptyName。InvalidAge,}
fn register->Result<,RegisterErr>{
if name.is_empty{return Err;}
if age <18 {return Err;}
Ok)
}
fn main{
match register{
Ok => println!,Err=>println!,}
}
配置文件解析
假设配置行为 `"port=8080"`：
rust
use std::{fs};fn parse_port->Result{
let parts : Vec<&str>=text.split.collect;if parts.len!=2 {return Err);}
parts.parse::
.map_err)
}
fn main{
match parse_port{
Ok=>println!,Err=>println!,}
}
