Result 匹配处理 ​

核心概念 ​

Result<T, E> 是 Rust 中处理可恢复错误的核心类型,由两个变体组成:Ok(T) 表示操作成功并携带结果值,Err(E) 表示操作失败并携带错误信息。和 Option 类似,Result 强制调用者处理错误情况——你无法直接使用 Result 中的值,必须先通过模式匹配或方法将其取出。

rust
// 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 完整匹配 ​

rust
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 ​

rust
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 系列方法 ​

rust
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

转换方法 ​

rust
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);
}

判断方法 ​

rust
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 的互转 ​

rust
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 匹配处理实现一个配置文件解析器:

rust
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 系列做安全的默认值回退。