Result 匹配处理
核心概念
Result<T, E> 是 Rust 中处理可恢复错误的核心类型,由两个变体组成:Ok(T) 表示操作成功并携带结果值,Err(E) 表示操作失败并携带错误信息。和 Option 类似,Result 强制调用者处理错误情况——你无法直接使用 Result 中的值,必须先通过模式匹配或方法将其取出。
// Result 在标准库中的定义
// enum Result<T, E> {
// Ok(T), // 成功,携带值
// Err(E), // 失败,携带错误
// }
use std::num::ParseIntError;
fn parse_number(s: &str) -> Result<i32, ParseIntError> {
s.parse::<i32>()
}
fn main() {
let good = parse_number("42");
let bad = parse_number("abc");
// match 处理 Result
match good {
Ok(n) => println!("解析成功: {}", n),
Err(e) => println!("解析失败: {}", e),
}
match bad {
Ok(n) => println!("解析成功: {}", n),
Err(e) => println!("解析失败: {}", e),
}
}match 完整匹配
use std::fs;
use std::io;
fn read_config(path: &str) -> Result<String, io::Error> {
fs::read_to_string(path)
}
fn main() {
// match 处理所有情况
let config = match read_config("config.toml") {
Ok(content) => {
println!("配置文件读取成功");
content
}
Err(e) => {
// 可以根据错误类型做不同处理
match e.kind() {
io::ErrorKind::NotFound => {
println!("配置文件不存在,使用默认配置");
String::from("port = 8080\nhost = localhost")
}
io::ErrorKind::PermissionDenied => {
println!("没有读取权限,使用默认配置");
String::from("port = 8080")
}
_ => {
println!("读取失败: {},使用空配置", e);
String::new()
}
}
}
};
println!("最终配置:\n{}", config);
}if let 和 let else
use std::collections::HashMap;
fn find_value(map: &HashMap<String, String>, key: &str) -> Result<String, String> {
map.get(key)
.map(|v| v.clone())
.ok_or_else(|| format!("键 '{}' 不存在", key))
}
fn process_config() -> Result<(), String> {
let mut config = HashMap::new();
config.insert(String::from("host"), String::from("localhost"));
config.insert(String::from("port"), String::from("8080"));
// if let:只关心成功
if let Ok(host) = find_value(&config, "host") {
println!("主机: {}", host);
}
// if let:只关心失败
if let Err(e) = find_value(&config, "missing") {
println!("预期的错误: {}", e);
}
// let else:不成功就提前返回
let Ok(port_str) = find_value(&config, "port") else {
return Err(String::from("缺少端口配置"));
};
let Ok(port) = port_str.parse::<u16>() else {
return Err(format!("端口 '{}' 无效", port_str));
};
println!("端口: {}", port);
Ok(())
}
fn main() {
match process_config() {
Ok(()) => println!("配置处理完成"),
Err(e) => println!("配置处理失败: {}", e),
}
}unwrap 系列方法
fn main() {
let ok_val: Result<i32, &str> = Ok(42);
let err_val: Result<i32, &str> = Err("出错了");
// unwrap:成功返回值,失败 panic
println!("unwrap: {}", ok_val.unwrap());
// err_val.unwrap(); // panic
// expect:和 unwrap 一样,但带自定义消息
println!("expect: {}", ok_val.expect("不应该失败"));
// err_val.expect("关键操作失败"); // panic: 关键操作失败: "出错了"
// unwrap_or:失败时返回默认值
println!("unwrap_or: {}", err_val.unwrap_or(0));
// unwrap_or_else:失败时用闭包计算默认值
let val = err_val.unwrap_or_else(|e| {
println!("遇到错误: {},使用计算默认值", e);
-1
});
println!("unwrap_or_else: {}", val);
// unwrap_or_default:失败时返回类型的 Default 值
let val: Result<i32, &str> = Err("error");
println!("unwrap_or_default: {}", val.unwrap_or_default()); // 0
// unwrap_err:提取错误值(成功时 panic)
println!("unwrap_err: {}", err_val.unwrap_err());
}| 方法 | Ok 时 | Err 时 | 适用场景 |
|---|---|---|---|
unwrap() | 返回值 | panic | 测试、确定成功 |
expect("msg") | 返回值 | panic 带消息 | 比 unwrap 更好 |
unwrap_or(default) | 返回值 | 返回 default | 有默认值 |
unwrap_or_else(f) | 返回值 | 调用 f | 默认值需计算 |
unwrap_or_default() | 返回值 | 返回 Default | 类型有 Default |
转换方法
fn main() {
let ok_val: Result<i32, String> = Ok(10);
let err_val: Result<i32, String> = Err(String::from("错误"));
// map:转换 Ok 中的值
let doubled = ok_val.map(|n| n * 2); // Ok(20)
let mapped_err = err_val.map(|n| n * 2); // Err("错误")
println!("map Ok: {:?}", doubled);
println!("map Err: {:?}", mapped_err);
// map_err:转换 Err 中的值
let ok_mapped = ok_val.map_err(|e| format!("包装: {}", e)); // Ok(10)
let err_mapped = err_val.map_err(|e| format!("包装: {}", e)); // Err("包装: 错误")
println!("map_err Ok: {:?}", ok_mapped);
println!("map_err Err: {:?}", err_mapped);
// and_then:链式操作(类似 flatmap)
let result = Ok(5)
.and_then(|n: i32| {
if n > 0 { Ok(n * 10) } else { Err("必须为正") }
})
.and_then(|n| {
if n < 100 { Ok(n + 1) } else { Err("太大了") }
});
println!("and_then: {:?}", result); // Ok(51)
// or:如果是 Err,用备选 Result 替代
let fallback: Result<i32, &str> = Err("失败").or(Ok(99));
println!("or: {:?}", fallback); // Ok(99)
// or_else:如果是 Err,用闭包生成备选
let recovered: Result<i32, &str> = Err("失败").or_else(|e| {
println!("尝试恢复: {}", e);
Ok(0)
});
println!("or_else: {:?}", recovered);
}判断方法
fn main() {
let ok: Result<i32, &str> = Ok(42);
let err: Result<i32, &str> = Err("error");
// is_ok / is_err
println!("ok.is_ok(): {}", ok.is_ok()); // true
println!("ok.is_err(): {}", ok.is_err()); // false
println!("err.is_ok(): {}", err.is_ok()); // false
println!("err.is_err(): {}", err.is_err()); // true
// is_ok_and(Rust 1.70+):判断是 Ok 且满足条件
println!("is_ok_and > 10: {}", ok.is_ok_and(|&n| n > 10)); // true
println!("is_ok_and > 100: {}", ok.is_ok_and(|&n| n > 100)); // false
println!("err is_ok_and: {}", err.is_ok_and(|&n| n > 0)); // false
// is_err_and(Rust 1.70+)
let err2: Result<i32, String> = Err(String::from("not found"));
println!("is_err_and: {}", err2.is_err_and(|e| e.contains("not found")));
}Result 与 Option 的互转
fn main() {
// Result → Option
let ok: Result<i32, &str> = Ok(42);
let err: Result<i32, &str> = Err("失败");
// ok():Ok → Some,Err → None(丢弃错误信息)
let opt1: Option<i32> = ok.ok(); // Some(42)
let opt2: Option<i32> = err.ok(); // None
println!("ok(): {:?}, {:?}", opt1, opt2);
// err():Err → Some,Ok → None
let opt3: Option<&str> = ok.err(); // None
let opt4: Option<&str> = err.err(); // Some("失败")
println!("err(): {:?}, {:?}", opt3, opt4);
// Option → Result
let some: Option<i32> = Some(42);
let none: Option<i32> = None;
// ok_or:None → Err(提供的错误值)
let res1: Result<i32, &str> = some.ok_or("空值"); // Ok(42)
let res2: Result<i32, &str> = none.ok_or("空值"); // Err("空值")
println!("ok_or: {:?}, {:?}", res1, res2);
// ok_or_else:None → Err(闭包计算的错误值)
let res3 = none.ok_or_else(|| String::from("未找到"));
println!("ok_or_else: {:?}", res3);
// transpose:Option<Result<T, E>> ↔ Result<Option<T>, E>
let opt_res: Option<Result<i32, &str>> = Some(Ok(42));
let res_opt: Result<Option<i32>, &str> = opt_res.transpose();
println!("transpose: {:?}", res_opt); // Ok(Some(42))
}基本示例
用 Result 匹配处理实现一个配置文件解析器:
use std::collections::HashMap;
#[derive(Debug)]
enum ConfigError {
EmptyInput,
InvalidLine(usize, String), // 行号, 原始行内容
DuplicateKey(String), // 重复的键
MissingRequired(String), // 缺少必要的键
InvalidValue(String, String), // 键, 值
}
impl std::fmt::Display for ConfigError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ConfigError::EmptyInput => write!(f, "输入为空"),
ConfigError::InvalidLine(line, content) => {
write!(f, "第{}行格式无效: '{}'", line, content)
}
ConfigError::DuplicateKey(key) => {
write!(f, "重复的键: '{}'", key)
}
ConfigError::MissingRequired(key) => {
write!(f, "缺少必要的配置: '{}'", key)
}
ConfigError::InvalidValue(key, val) => {
write!(f, "键 '{}' 的值 '{}' 无效", key, val)
}
}
}
}
#[derive(Debug)]
struct AppConfig {
host: String,
port: u16,
debug: bool,
workers: u32,
}
// 解析单行配置
fn parse_line(line_num: usize, line: &str) -> Result<Option<(String, String)>, ConfigError> {
let trimmed = line.trim();
// 空行或注释行
if trimmed.is_empty() || trimmed.starts_with('#') {
return Ok(None);
}
// 查找 = 号
let eq_pos = trimmed.find('=')
.ok_or_else(|| ConfigError::InvalidLine(line_num, line.to_string()))?;
let key = trimmed[..eq_pos].trim().to_string();
let value = trimmed[eq_pos + 1..].trim().to_string();
if key.is_empty() {
return Err(ConfigError::InvalidLine(line_num, line.to_string()));
}
Ok(Some((key, value)))
}
// 解析所有行为键值对
fn parse_pairs(input: &str) -> Result<HashMap<String, String>, ConfigError> {
if input.trim().is_empty() {
return Err(ConfigError::EmptyInput);
}
let mut map = HashMap::new();
for (i, line) in input.lines().enumerate() {
// 用 match 处理每行的解析结果
match parse_line(i + 1, line) {
Ok(Some((key, value))) => {
if map.contains_key(&key) {
return Err(ConfigError::DuplicateKey(key));
}
map.insert(key, value);
}
Ok(None) => {
// 空行或注释,跳过
}
Err(e) => {
return Err(e);
}
}
}
Ok(map)
}
// 从键值对构建配置
fn build_config(pairs: &HashMap<String, String>) -> Result<AppConfig, ConfigError> {
// 必要字段检查
let host = pairs.get("host")
.ok_or_else(|| ConfigError::MissingRequired(String::from("host")))?
.clone();
let port_str = pairs.get("port")
.ok_or_else(|| ConfigError::MissingRequired(String::from("port")))?;
let port = port_str.parse::<u16>()
.map_err(|_| ConfigError::InvalidValue(String::from("port"), port_str.clone()))?;
// 可选字段,使用默认值
let debug = pairs.get("debug")
.map(|v| match v.as_str() {
"true" | "1" => Ok(true),
"false" | "0" => Ok(false),
_ => Err(ConfigError::InvalidValue(String::from("debug"), v.clone())),
})
.transpose()? // Option<Result> → Result<Option>
.unwrap_or(false);
let workers = pairs.get("workers")
.map(|v| v.parse::<u32>()
.map_err(|_| ConfigError::InvalidValue(String::from("workers"), v.clone())))
.transpose()?
.unwrap_or(4);
Ok(AppConfig { host, port, debug, workers })
}
// 完整的解析流程
fn load_config(input: &str) -> Result<AppConfig, ConfigError> {
let pairs = parse_pairs(input)?;
build_config(&pairs)
}
fn main() {
// 正确的配置
let good_config = r#"
# 服务器配置
host = localhost
port = 8080
debug = true
workers = 8
"#;
match load_config(good_config) {
Ok(config) => println!("加载成功: {:?}", config),
Err(e) => println!("加载失败: {}", e),
}
// 缺少必要字段
let missing_port = "host = localhost\ndebug = true";
match load_config(missing_port) {
Ok(config) => println!("加载成功: {:?}", config),
Err(e) => println!("加载失败: {}", e),
}
// 无效的值
let bad_port = "host = localhost\nport = abc";
match load_config(bad_port) {
Ok(config) => println!("加载成功: {:?}", config),
Err(e) => println!("加载失败: {}", e),
}
// 格式错误
let bad_format = "host = localhost\n这不是合法行\nport = 8080";
match load_config(bad_format) {
Ok(config) => println!("加载成功: {:?}", config),
Err(e) => println!("加载失败: {}", e),
}
// 空输入
match load_config("") {
Ok(config) => println!("加载成功: {:?}", config),
Err(e) => println!("加载失败: {}", e),
}
// 默认值
let minimal = "host = 0.0.0.0\nport = 3000";
match load_config(minimal) {
Ok(config) => println!("最小配置: {:?}", config),
Err(e) => println!("加载失败: {}", e),
}
}常见问题
问题一:Result 和 Option 怎么选?
需要知道失败原因时用 Result,只关心有没有值时用 Option。IO 操作、解析、验证等用 Result;查找、可选字段用 Option。
问题二:match 和 unwrap_or 哪个好?
取决于场景。需要对错误做不同处理时用 match。只需要成功值或默认值时用 unwrap_or 系列更简洁。两者可以混合使用。
问题三:and_then 和 map 有什么区别?
map 的闭包返回普通值 T,结果自动包装为 Ok(T)。and_then 的闭包返回 Result<U, E>,用于闭包自身也可能失败的情况,避免 Result<Result<T, E>, E> 嵌套。
问题四:transpose 是做什么的?
transpose 在 Option<Result<T, E>> 和 Result<Option<T>, E> 之间转换。当你有一个可选的可能失败的操作时很有用:可选字段存在时解析它,不存在时返回 None。
适用场景
- 文件读取:
match根据错误类型决定回退方案 - 数据解析:
and_then链式处理多步解析 - 参数验证:
let else提前返回错误 - 默认值回退:
unwrap_or提供安全的默认值
注意事项
Result必须被处理,忽略Result会产生编译器警告unwrap和expect会 panic,生产代码慎用map转换 Ok 值,map_err转换 Err 值and_then用于闭包自身也返回 Result 的场景?操作符是match + return Err的简写(后续章节详细介绍)transpose在 Option 和 Result 之间转换is_ok_and和is_err_and需要 Rust 1.70+
总结
Result<T, E> 是 Rust 处理可恢复错误的核心类型。通过 match 可以完整处理 Ok 和 Err 两种情况,通过 if let 和 let else 可以只关心其中一种。unwrap 系列方法提供了带默认值的快捷取值方式。map、map_err、and_then 等方法支持链式转换。Result 和 Option 可以通过 ok()、ok_or()、transpose() 互相转换。处理 Result 的关键原则是:用 match 做详细的错误分类处理,用链式方法做简洁的数据转换,用 unwrap_or 系列做安全的默认值回退。