错误处理

这一课你将能做到

1. 区分 panic! 与 Result 的适用边界，杜绝「图省事一路 unwrap」
2. 熟练使用 ? 运算符传播错误，实现自定义错误类型并完成 From 转换
3. 用 Option/Result 组合子链式处理「可能失败」的值

为什么要学

Java 用异常处理错误：try-catch 隐藏在调用栈里，方法签名看不出会不会炸，checked exception 还常年被绕过。Rust 把错误写进函数签名——Result<T, E> 类型上声明「我可能失败，失败长这样」，编译器强制调用方表态。

对高性能后端这有两个实际收益：错误路径无异常展开的开销（返回值即错误），以及读代码时一眼看清所有失败分支。? 运算符让错误传播从 Java 的层层 try-catch 变成一个字符。

先建立图像

Java：                      Rust：
int parse(String s)         fn parse(s: &str) -> Result<u32, ParseIntError>
throws NumberFormatException
                            调用方三选一（编译器强制）：
try-catch 掩盖路径          ① ? 直接上抛
                            ② match 拆开处理
                            ③ unwrap/expect 显式声明「这里不可能失败」

两个错误世界的分工：

• panic!：不可恢复的 bug（数组越界、断言失败），对标 Java 的 RuntimeException 直接炸进程/线程
• Result<T, E>：可预期的失败（解析失败、文件不存在、上游超时），对标 checked exception 但更诚实

跟着做

步骤 1：Result 的基本形状

cargo new err-demo
cd err-demo

use std::num::ParseIntError;

fn parse_time_limit(raw: &str) -> Result<u32, ParseIntError> {
    raw.trim().parse::<u32>()
}

fn main() {
    match parse_time_limit(" 1000 ") {
        Ok(ms) => println!("时限 {ms} ms"),
        Err(e) => println!("解析失败：{e}"),
    }

    match parse_time_limit("abc") {
        Ok(ms) => println!("时限 {ms} ms"),
        Err(e) => println!("解析失败：{e}"),
    }
}

Result<u32, ParseIntError>：成功带 u32，失败带错误详情。" 1000 ".trim().parse() 是标准库字符串转数字的惯用链。

步骤 2：? 运算符——错误传播的最短路径

fn read_limit(line: &str) -> Result<u32, String> {
    let (_, raw) = line.split_once('=').ok_or("缺少 '=' 分隔符")?;
    //                                  ^ 拆不出 '=' 就提前返回 Err（&str 自动转 String）
    let limit = raw.trim().parse::<u32>().map_err(|e| e.to_string())?;
    //                                     ^ 解析失败自动 return Err
    Ok(limit)
}

fn main() {
    println!("{:?}", read_limit("time_limit = 2000"));
    println!("{:?}", read_limit("garbage-line"));
}

? 做三件事：检查 Result、失败则携带错误提前 return、成功则取出 Ok 里的值。一个字符顶掉 Java 的三层 try-catch。注意 只能在返回 Result 的函数里用。