Rust 错误处理 简记

已于 2023-01-04 20:29:30 修改
阅读量1.4k 收藏
点赞数
分类专栏： Rust 文章标签： rust Error thiserror Result panic
于 2023-01-04 20:23:47 首次发布
原文链接：https://blog.csdn.net/weifengdq?spm=1019.2139.3001.5343
版权

Rust 错误处理

文章目录

错误简介

Rust 有错误, 无异常, Rust 错误的两个主要类别:

  • 可恢复错误(recoverable), 如 Option<T> 或 Result<T, E>泛型
  • 不可恢复错误(unrecoverable), 如 panic!宏

panic!

当出现panic(恐慌)时, 有两种选择:

  • 展开(unwinding), 默认, Rust会回溯(backtrace)栈并清理遇到的每个函数的数据. Debug的时候可以 RUST_BACKTRACE=1 cargo run 或 RUST_BACKTRACE=full cargo run 对 panic 回溯
  • 终止(abort), 不清理直接退出, 内存由操作系统清理, Release时可以在Cargo.toml文件设置panic时终止, 这样生成的二进制也会小一些, 设置如下
[profile.release]
panic = 'abort'

直接 panic

fn main() {
    panic!("crash and burn");
}

// thread 'main' panicked at 'crash and burn', src/main.rs:3:5
// note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

panic 的发生(如除零, 数组越界, 缓冲区溢出等)

fn main() {
    let div = |x: i32, y: i32| -> i32 { x / y };
    println!("div(10, 0) = {}", div(10, 0));  // panic
}

// thread 'main' panicked at 'attempt to divide by zero', src/main.rs:3:41
// note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

示例, 代码原型和测试都很适合 panic

Option

Option的原型是枚举

pub enum Option<T> {
    None,
    Some(T),
}

Rust没有null, 可以用Option的None, 碰到错误返回None

fn main() {
    let div = |x: i32, y: i32| -> Option<i32> {
        match y {
            0 => None,
            _ => Some(x / y),
        }
    };
    println!("div(10, 2) = {}", div(10, 2).unwrap());   // 5
    println!("div(10, 2) = {:?}", div(10, 2));        // Some(5)
    println!("div(10, 0) = {:?}", div(10, 0));      // None
    println!("div(10, 0) = {:?}", div(10, 0).unwrap_or(0));   // 0
    println!("div(10, 0) = {:?}", div(10, 0).unwrap_or_else(|| 0));   // 0
    // println!("div(10, 0) = {}", div(10, 0).unwrap()); // panic
}

Result

Result的原型是枚举, 函数可以不管单个或多个错误是什么, 可以直接打印错误情况, 也可以直接往上抛, 透传错误, 看后人的智慧

enum Result<T, E> {
    Ok(T),
    Err(E),
}

返回 String 的例子, 结果参考注释

fn main() {
    let div = |x: i32, y: i32| -> Result<i32, String> {
        match y {
            0 => Err("Division by zero".to_string()),
            _ => Ok(x / y),
        }
    };
    println!("div(10, 2) = {}", div(10, 2).unwrap());   // 5
    println!("div(10, 0) = {}", div(10, 0).unwrap_err());   // Division by zero
    println!("div(10, 0) = {:?}", div(10, 0).err());    // Some("Division by zero")
    println!("div(10, 0) = {:?}", div(10, 0).ok()); // None
    println!("div(10, 0) = {:?}", div(10, 0).unwrap_or(0)); // 0
    println!("div(10, 0) = {:?}", div(10, 0).unwrap_or_else(|e| {
        println!("Error: {}", e);   // Error: Division by zero
        0   // 0 is the return value
    }));
    // println!("div(10, 0) = {}", div(10, 0).unwrap());    // panic
}

更多时候不返回String, 而是返回 std::io::Error

    let div = |x: i32, y: i32| -> Result<i32, std::io::Error> {
        match y {
            0 => Err(std::io::Error::new(std::io::ErrorKind::Other, "Division by zero")),
            _ => Ok(x / y),
        }
    };

? 操作符, 类似 .unwrap()

fn main() {
    let read_file = |filename: &str| -> Result<String, std::io::Error> {
        let mut f = std::fs::File::open(filename)?;
        let mut s = String::new();
        std::io::Read::read_to_string(&mut f, &mut s)?;
        Ok(s)
    };
    match read_file("./Cargo.toml") {
        Ok(s) => println!("read_file(\"./Cargo.toml\") = {}", s),
        Err(e) => println!("read_file(\"./Cargo.toml\") = {:?}", e),
    }
    // Os { code: 2, kind: NotFound, message: "No such file or directory" }
    println!("read_file(\"./Cargo1.toml\") = {:?}", read_file("./Cargo1.toml").unwrap_err());
    // Some(Os { code: 2, kind: NotFound, message: "No such file or directory" })
    println!("read_file(\"./Cargo1.toml\") = {:?}", read_file("./Cargo1.toml").err());
    // None
    println!("read_file(\"./Cargo1.toml\") = {:?}", read_file("./Cargo1.toml").ok());
    // ""
    println!("read_file(\"./Cargo1.toml\") = {:?}", read_file("./Cargo1.toml").unwrap_or("".to_string()));
}

main 也可以返回 Result, 这样可以通篇 ? 操作符, 有错误就直接panic, 停止程序的运行

fn main() -> Result<(), std::io::Error> {
    let div = |x: i32, y: i32| -> Result<i32, std::io::Error> {
        match y {
            0 => Err(std::io::Error::new(std::io::ErrorKind::Other, "Division by zero")),
            _ => Ok(x / y),
        }
    };
    println!("div(10, 2) = {}", div(10, 2)?);
    // Error: Custom { kind: Other, error: "Division by zero" }
    // println!("div(10, 0) = {:?}", div(10, 0)?);
    let read_file = |filename: &str| -> Result<String, std::io::Error> {
        let mut f = std::fs::File::open(filename)?;
        let mut s = String::new();
        std::io::Read::read_to_string(&mut f, &mut s)?;
        Ok(s)
    };
    // Error: Os { code: 2, kind: NotFound, message: "No such file or directory" }
    println!("read_file(\"temp.txt\") = {}", read_file("temp.txt")?);
    Ok(())
}

不返回 std::io::Error 或 Box<std::io::Error>, 可以自定义Error对所有错误进行统一管理, 需要实现 Error, From等trait

// 可以把MyError放外面, main也不用返回std::io::Error
fn main() -> Result<(), std::io::Error> {
    #[derive(Debug)]
    enum MyError {
        DivByZero(String),
        Io(std::io::Error),
        Parse(std::num::ParseIntError),
    }
    impl From<std::io::Error> for MyError {
        fn from(err: std::io::Error) -> MyError {
            MyError::Io(err)
        }
    }
    impl From<std::num::ParseIntError> for MyError {
        fn from(err: std::num::ParseIntError) -> MyError {
            MyError::Parse(err)
        }
    }
    impl From<MyError> for std::io::Error {
        fn from(err: MyError) -> std::io::Error {
            match err {
                MyError::Io(err) => err,
                _ => std::io::Error::new(std::io::ErrorKind::Other, err),
            }
        }
    }
    impl std::fmt::Display for MyError {
        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
            match self {
                MyError::DivByZero(msg) => write!(f, "DivByZero({})", msg),
                MyError::Io(err) => write!(f, "Io({})", err),
                MyError::Parse(err) => write!(f, "Parse({})", err),
            }
        }
    }
    impl std::error::Error for MyError {
        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
            match self {
                MyError::Io(err) => Some(err),
                MyError::Parse(err) => Some(err),
                _ => None,
            }
        }
    }

    let div = |x: i32, y: i32| -> Result<i32, MyError> {
        match y {
            0 => Err(MyError::DivByZero("Division by zero".to_string())),
            _ => Ok(x / y),
        }
    };
    println!("div(10, 0) = {}", div(10, 0).unwrap_err()); // DivByZero(Division by zero)
    println!("div(10, 2) = {}", div(10, 2)?);

    let read_int = || -> Result<i32, MyError> {
        let mut input = String::new();
        std::io::stdin().read_line(&mut input)?;
        let n: i32 = input.trim().parse()?;
        Ok(n)
    };
    let x = read_int()?;
    println!("x = {}", x);

    let read_file = |filename: &str| -> Result<String, MyError> {
        let mut f = std::fs::File::open(filename)?;
        let mut s = String::new();
        std::io::Read::read_to_string(&mut f, &mut s)?;
        Ok(s)
    };
    let s = read_file("temp.rs")?;
    println!("s = {}", s);

    Ok(())
}

上面的一堆看着都头疼, 可以使用 dtolnay/thiserror: derive(Error) for struct and enum error types (github.com) 进行简化, Cargo.toml添加

[dependencies]
thiserror = "1.0.38"

然后main.rs就可以简写如下, 这样看着就清爽了很多

#[derive(Debug, thiserror::Error)]
enum MyError {
    #[error("Division by zero")]
    DivByZero,
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    #[error("Parse error: {0}")]
    Parse(#[from] std::num::ParseIntError),
}

fn main() -> Result<(), MyError> {
    let div = |x: i32, y: i32| -> Result<i32, MyError> {
        match y {
            0 => Err(MyError::DivByZero),
            _ => Ok(x / y),
        }
    };
    println!("div(10, 0) = {}", div(10, 0).unwrap_err()); // DivByZero(Division by zero)
    println!("div(10, 2) = {}", div(10, 2)?);

    let read_int = || -> Result<i32, MyError> {
        let mut input = String::new();
        std::io::stdin().read_line(&mut input)?;
        let n: i32 = input.trim().parse()?;
        Ok(n)
    };
    let x = read_int()?;
    println!("x = {}", x);

    let read_file = |filename: &str| -> Result<String, MyError> {
        let mut f = std::fs::File::open(filename)?;
        let mut s = String::new();
        std::io::Read::read_to_string(&mut f, &mut s)?;
        Ok(s)
    };
    let s = read_file("temp.rs")?;
    println!("s = {}", s);

    Ok(())
}

参考

如有错误, 敬请指正, 参考如下:

欢迎扫描二维码关注微信公众号, 及时获取最新文章:
在这里插入图片描述

weifengdq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
崩溃转储（rust）
luo222的专栏
03-30 1047
# 崩溃转储 ## google breakpad ### 使用 breakpad不需要安装，使用方式为侵入式的，需要引入额外代码，可以作为外部库引入，也可以直接使用源码。breakpad 对进程（操作系统进程）有效，一次引入所有模块均有效。breakpad使用时需要提供库（或可执行文件）对应的 text-format symbol files（windows下为 .pdb文件，linux下为.s...
Rust嵌入式编程---panic处理和异常处理
phthon1997的博客
09-29 1490
异常意味着抢占，并涉及异常处理程序，即响应触发事件的信号而执行的子例程，这就是和。是硬件上的，而panic理解成软件上的，比如访问文件不存在啊、访问越界啊、除0操作等等，而且panic一般没有那么多处理方式，没有抢占和触发panic处理程序等等。在标准库（Std）中，panic有一个定义的行为：它展开 panic 线程的堆栈，除非用户选择在 panic 时中止程序，否则会进行错误位置的一个堆栈定位。该值是发生异常时程序计数器的值，它指向触发异常的指令，所以可以看一下pc的值指向的指令就是错误的地方。
Rust从入门到暴走（20）--- Rust的单元测试
Luca的博客, 网络安全Hacker，人工智能AIer，区块链Web3er，全栈软件开发er
04-02 457
在这个例子中，我们定义了一个 Rectangle 结构体，并实现了一个 area 方法来计算矩形的面积。然后在测试模块中编写了单元测试函数 test_rectangle_area，用于测试 area 方法是否正确计算面积。
Rust 在 Windows 下查看函数的 backtrace 命令
Always
01-28 600
Rust 在 Window 下查看函数的backtrace命令 $env:RUST_BACKTRACE=1 ; cargo run（cargo run 后面还可以加其他环境变量） 补充：读 backtrace 信息时应该从头开始读直到发现我们所编写的文件，这一行往上是 我们代码 所调用的代码；往下则是 调用我们代码 的代码。 ...
Rust backtrace栈展开
weixin_48602203的博客
12-19 455
栈回溯信息按照逆序排列，最近调用的函数排在列表最上方，排在最顶部的函数（也就是最后一个调用的函数）时rust_begin_unwind，该函数就是用于进行栈展开并呈现列表信息。
【Rust日报】2022-11-01 async-backtrace 发布
Rust语言学习交流
11-01 205
async-backtrace 发布tokio 官方团队近日发布了async-backtrace的初个版本，旨在让开发者能够高效地追踪应用中异步任务的状态。使用步骤如下：首先将该 crate 加入到Cargo.toml文件中:[dependencies] async-backtrace = "0.2"使用#[async_backtrace::framed]标注一个异步函数可用于追踪，使...
rust错误处理笔记项目
10-11
rust错误处理笔记项目
错误处理项目组-Rust开发
05-27
专注于定义和交流Rust的错误处理故事。 错误处理项目组欢迎来到错误处理项目组的存储库！ 我们专注于定义和交流Rust的错误处理故事。 这是我们用来组织工作的存储库。 有关我们的目标和当前范围的更多信息，请参考...
rust-eh:更多关于 Rust 的错误处理实验
07-12
生锈这是一个错误处理实验。 主要是尝试将 Python 回溯的可调试性引入 Rust 结果。 当前状态： Traceback (most recent cause last): File "/Users/mitsuhiko/Development/rust-eh/examples/test.rs", line 42 fail!...
数据处理-Rust熊猫
03-03
数据处理：Pandas vs Rust 在以下位置下载数据： 运行python代码： 取消注释您感兴趣的部分python src/python_benchmark.py 运行锈代码： 取消注释您感兴趣的部分cargo build --release target/release/terrorism
rust-incidents:Rust 中更多的错误处理实验
05-29
这个库为 Rust 中的错误处理提供了一个实验。 它提供高效的错误处理并提供强大的调试功能。 通过提供可取消引用的故障类型来保持较小的结果 在调试版本中提供对 python 样式回溯的支持 允许错误可以通过FromError...
在 windows 中设置环境变量 RUST_BACKTRACE=1, RUST_BACKTRACE=full
零一魔法
06-17 1913
设置环境变量 RUST_BACKTRACE=1, RUST_BACKTRACE=full
Rust 程序设计语言 第十一章编写自动化测试
weixin_51311741的博客
06-15 868
你也可以向assert!assert_eq!和assert_ne!宏传递一个可选的失败信息参数，可以在测试失败时将自定义失败信息一同打印出来。任何在assert!的一个必需参数和assert_eq!和assert_ne!的两个必需参数之后指定的参数都会传递给format!宏（在第八章的“使用运算符或format!宏拼接字符串”部分讨论过），所以可以传递一个包含{}占位符的格式字符串和需要放入占位符的值。自定义信息有助于记录断言的意义；当测试失败时就能更好的理解代码出了什么问题。
快速了解：Rust 的错误处理
程序猿视角
08-02 1226
panic! 宏 —— 粗暴地抛出错误 在程序中抛出产生错误信息很容易，用 panic! 宏即可，程序运行到 panic! 会无条件结束，并返回错误信息。 fn main() { panic!("error!"); println!("Hello, world!"); } ================ run result ============== thread 'main' panicked at 'error!', src\main.rs:2:5 note: run w
Rust中的返回值与错误处理
小米子的成长日记
10-13 386
Rust 中的错误主要分为两类： - **可恢复错误**，通常用于从系统全局角度来看可以接受的错误，例如处理用户的访问、操作等错误，这些错误只会影响某个用户自身的操作进程，而不会对系统的全局稳定性产生影响，`Result` 用于可恢复错误 - **不可恢复错误**，刚好相反，该错误通常是全局性或者系统性的错误，例如数组越界访问，系统启动时发生了影响启动流程的错误等等，这些错误的影响往往对于系统来说是致命的，`panic!` 用于不可恢复错误。
Rust从入门到实战系列一百二十五：修复错误处理
wanmeijuhao的博客
03-05 403
现在我们开始修复错误处理。回忆一下之前提到过如果 args vector 包含少于 3 个项并尝试访问 vector中索引 1 或索引 2 的值会造成程序 panic。尝试不带任何参数运行程序；这将看起来像这样：Runningindex out of bounds: the len is 1 but the index is 1 是一个针对程序员的错误信息，然而这并不能真正帮助终端用户理解发生了什么和他们应该做什么。现在就让我们修复它吧。改善错误信息。
rust多个属性宏叠加_Rust“与众不同”的地方
weixin_28907839的博客
12-23 530
最近了解了一下Rust，感受到满满的“诡异”。相比较C，C++，java，python以及Go，Rust似乎十分的特别。同样都号称C++的替代者，如果说是Go是简洁为王，Rust则是霸气测漏。Go吸引了大量的Python，PHP的用户，而C++用户则更倾向于Rust，因为Rust似乎更像安全版本的C++。简单汇总一下Rust中比较特殊的“创造”。变量默认是不可变的一个变量，字面意思是可变量，不管是...
减少Rust开发的闭源项目中的调试信息
systemino的博客
07-24 1806
Rust是一门系统编程语言，专注于安全，尤其是并发安全，支持函数式和命令式以及泛型等编程范式的多范式语言。Rust在语法上和C++类似，但是设计者想要在保证性能的同时提供更好的内存安全。 由于Rust有几千行代码，所以我无论如何都不能自称是Rust专家，但这并不妨碍我对Rust的理解。我非常喜欢Rust的语法，与其他许多语言相比，Rust的具体语法和C，C++类似，都是由花括号限定代码块，还有一...
rust 函数基础
每天进步一点点
07-04 1367
rust 函数定义，发散函数，函数指针// 函数定义和参数声明 // 必须为参数声明类型 // 只能返回一个返回值 fn add(x: i32, y: i32) -> i32 { println!("x + y = {}", x + y); x + y // 返回值不加；为表达式 // 可以使用 return 提早返回不放在最后一行 }// 发散函数 (D
rust错误处理的好处
最新发布
05-16
Rust的错误处理机制有许多好处，下面是其中几个： 1. 静态类型检查：Rust的错误处理机制是在编译时进行静态类型检查，这意味着在运行时出现的错误可以在编译时被捕获并修复，避免了一些难以发现的运行时错误。 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值