Rust 如何优雅的处理Result和Option！
Rust 如何优雅的处理Result和Option！
- 一、Rust 如何优雅的处理Result和Option
- 1、基础模式匹配
- 1.1、 `match` 表达式
- 1.2、 `if let` 简化
- 2、组合子方法
- 2.1、`map` / `map_err`
- 2.2、`and_then`（链式操作）
- 2.3、 `unwrap_or` / `unwrap_or_else`
- 3、错误传播（`?` 运算符）
- 4、自定义错误类型
- 5、实用宏
- 5.1、`unwrap!` 的替代品
- 5.2、 `matches!` 宏
- 最、佳实践总结
- 二、代码示例
一、Rust 如何优雅的处理Result和Option
在 Rust 中，优雅处理 Result 和 Option 的核心在于 模式匹配、组合子和错误传播。以下是几种常用方法：
1、基础模式匹配
1.1、 match 表达式
// 处理 Option
fn get_length(s: Option<&str>) -> usize {
match s {
Some(text) => text.len(),
None => 0,
}
}
// 处理 Result
fn parse_number(s: &str) -> Result<i32, std::num::ParseIntError> {
match s.parse() {
Ok(n) => Ok(n),
Err(e) => Err(e),
}
}
1.2、 if let 简化
if let Some(value) = some_option {
println!("Value: {}", value);
} else {
println!("Value is None");
}
2、组合子方法
2.1、map / map_err
fn main() {
let opt = Some(5);
let squared = opt.map(|x| x * x); // Some(25)
println!("{:?}", squared);
let res: Result<i32, &str> = Ok(5);
let squared = res.map(|x| x * x); // Ok(25)
let error = res.map_err(|_| "new error"); // 仅当 Err 时转换
println!("{:?}", squared);
println!("{:?}", error);
}
2.2、and_then（链式操作）
fn main() {
fn sqrt(x: f64) -> Option<f64> {
if x >= 0.0 { Some(x.sqrt()) } else { None }
}
let num = Some(4.0);
let result = num.and_then(sqrt); // Some(2.0)
println!("{:?}", result);
}
2.3、 unwrap_or / unwrap_or_else
fn main() {
let opt: Option<i32> = None;
let value = opt.unwrap_or(0); // 0
println!("value: {}", value);
let res: Result<i32, &str> = Err("error");
let value = res.unwrap_or_else(|_| -1); // -1
println!("value: {}", value);
}
3、错误传播（? 运算符）
fn read_file(path: &str) -> Result<String, std::io::Error> {
let content = std::fs::read_to_string(path)?; // 自动传播错误
Ok(content)
}
fn get_first_char(s: Option<&str>) -> Option<char> {
let s = s?; // 若为 None 则提前返回
s.chars().next()
}
4、自定义错误类型
对于复杂场景，可组合错误类型：
#[derive(Debug)]
enum MyError {
Io(std::io::Error),
Parse(std::num::ParseIntError),
}
impl From<std::io::Error> for MyError {
fn from(e: std::io::Error) -> Self {
MyError::Io(e)
}
}
fn process() -> Result<(), MyError> {
let num: i32 = "123".parse().map_err(MyError::Parse)?;
let _file = std::fs::File::open("file.txt")?; // 自动转换错误类型
Ok(())
}
fn main() {
println!("{:?}", process());
}
5、实用宏
5.1、unwrap! 的替代品
let opt = Some(42);
let value = opt.expect("值不应为空"); // panic 时显示自定义消息
5.2、 matches! 宏
let res: Result<i32, &str> = Ok(42);
assert!(matches!(res, Ok(42)));
最、佳实践总结
- 优先使用
?传播错误，减少嵌套 - 组合子处理简单逻辑（
map/and_then） - 复杂分支用
match保证清晰性 - 自定义错误类型统一处理多来源错误
// 综合示例：链式处理
fn process_data(path: &str) -> Result<u32, MyError> {
let content = std::fs::read_to_string(path)?;
let num_str = content.lines().next().ok_or(MyError::EmptyFile)?;
num_str.parse().map_err(MyError::Parse)
}
二、代码示例
use std::fs::File;
use std::io::Read;
// 示例函数：读取文件并解析为数字
fn read_and_parse(file_path: &str) -> Result<i32, String> {
// 1. Option 处理：打开文件
let mut file = File::open(file_path).map_err(|e| format!("打开文件失败: {}", e))?;
// 2. Option 处理：读取内容
let mut content = String::new();
file.read_to_string(&mut content)
.map_err(|e| format!("读取失败: {}", e))?;
// 3. Option 处理：移除空白并解析
content.trim().parse::<i32>()
.map_err(|_| "解析数字失败".to_string())
}
fn main() {
let file_path = "data.txt";
// 4. Result 处理：组合方法
let result = read_and_parse(file_path)
.and_then(|num| {
if num > 0 {
Ok(num * 2)
} else {
Err("数字必须为正".into())
}
})
.map(|val| val.to_string());
// 5. 最终处理
match result {
Ok(s) => println!("处理结果: {}", s),
Err(e) => eprintln!("错误: {}", e),
}
// 6. Option 快捷处理
let opt_val: Option<i32> = Some(42);
println!("Option 值: {}", opt_val.unwrap_or(0));
// 7. Result 快捷处理
let _ = File::open("tmp.txt").unwrap_or_else(|_| File::create("tmp.txt").unwrap());
}
运行结果：
处理结果: 200
Option 值: 42
进程已结束，退出代码为 0
方法解析：
-
?运算符
自动传播错误，替代match的样板代码 -
map_err
转换错误类型：std::io::Error→String -
组合方法链
and_then用于连续操作，map用于值转换 -
unwrap_or
为Option提供默认值 -
unwrap_or_else
延迟计算默认值（避免不必要的性能开销） -
match终极处理
显式处理所有成功/错误分支
