Rust 错误处理

最新推荐文章于 2024-06-21 15:50:34 发布
最新推荐文章于 2024-06-21 15:50:34 发布
阅读量2.3k 收藏
点赞数 1
分类专栏： Rust 文章标签： rust
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hualuohuakai2014/article/details/113059368
版权

在编程语言中，处理错误的方式大致可分为两种：

  • 抛出异常
  • 作为值返回（返回一个错误代码或者自定义错误类型）

Rust 将错误作为值返回，并提供了原生的错误处理方案。在 Rust 中，错误可分为两种：

  • 可恢复错误（recoverable）—— Result<T, E>
  • 不可恢复错误（unrecoverable）—— panic!

panic!

panic! 是 Rust 提供的一个宏，这个宏在执行时会打印错误信息，展开并清理栈数据。

panic! 会导致当前线程结束，甚至是整个程序的结束。因此，panic! 通常适合用在编写的示例或者测试代码中。

示例：直接调用 panic! 宏

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

当出现 panic! 时，程序默认会展开（unwinding），即：程序会回溯栈并清理它遇到的每个函数的数据。另外，也可以选择直接终止（abort），不清理数据就退出程序，占用的内存需要操作系统来清理。如果要选择直接终止，需要在 Cargo.toml 文件中添加下面的配置：

# 在这样的配置下，项目生成的二进制文件会比较小。
[profile.release]
panic = 'abort'

栈回溯信息

当程序遇到 panic! 退出时，它会输出错误信息（即：panic!() 括号里的内容），以及发生错误的位置。并且它会提示你如何查看栈回溯（backtrace）信息。

示例：制造一个不可恢复错误

fn main() {
    let v = vec![1, 2, 3];

    v[99];
}

运行上面的代码：

PS D:\vscode\rust_demo\hello> cargo run
   Compiling hello v0.1.0 (D:\vscode\rust_demo\hello)
    Finished dev [unoptimized + debuginfo] target(s) in 1.18s
     Running `target\debug\hello.exe`
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src\main.rs:4:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: process didn't exit successfully: `target\debug\hello.exe` (exit code: 101)
PS D:\vscode\rust_demo\hello>

输出信息提示我们可以设置 RUST_BACKTRACE 环境变量来显示栈回溯信息。按照提示，重新运行程序，我们会看到详细的栈回溯信息：

PS D:\vscode\rust_demo\hello> $Env:RUST_BACKTRACE=1
PS D:\vscode\rust_demo\hello>
PS D:\vscode\rust_demo\hello> cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
     Running `target\debug\hello.exe`
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src\main.rs:4:5
stack backtrace:
   0: std::panicking::begin_panic_handler
             at /rustc/18bf6b4f01a6feaf7259ba7cdae58031af1b7b39\/library\std\src\panicking.rs:475
   1: core::panicking::panic_fmt
             at /rustc/18bf6b4f01a6feaf7259ba7cdae58031af1b7b39\/library\core\src\panicking.rs:85
   2: core::panicking::panic_bounds_check
             at /rustc/18bf6b4f01a6feaf7259ba7cdae58031af1b7b39\/library\core\src\panicking.rs:62
   3: core::slice::{{impl}}::index<i32>
             at C:\Users\wangzk\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\slice\mod.rs:3282
   4: core::slice::{{impl}}::index<i32,usize>
             at C:\Users\wangzk\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\slice\mod.rs:3123
   5: alloc::vec::{{impl}}::index<i32,usize>
             at C:\Users\wangzk\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\alloc\src\vec.rs:2000
   6: hello::main
             at .\src\main.rs:4
   7: core::ops::function::FnOnce::call_once<fn(),tuple<>>
             at C:\Users\wangzk\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\ops\function.rs:227
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
error: process didn't exit successfully: `target\debug\hello.exe` (exit code: 101)
PS D:\vscode\rust_demo\hello>

上面的示例是在 Windows 系统中运行的，设置环境变量的方式与 Linux 不同。若使用 CMD ，则执行 set RUST_BACKTRACE=1 命令。若使用 PowerShell ，则执行 $Env:RUST_BACKTRACE=1命令。

Option

Option<T> 是 Rust 标准库提供的一个枚举类型，它只有两个成员：

  • Some(T) – 包含一个 T 类型的值
  • None – 表示没有值

当使用 Option<T> 作为函数的参数或者返回值类型时，函数的创建者或调用者必须处理枚举值是 None 的情况，这样可以减少潜在的 bug。

示例：在字符串 haystack 中查找 needle 字符，并返回该字符的索引

// 返回值是 `Option<usize>`，用 `None` 来表示没有找到 needle 字符
fn find(haystack: &str, needle: char) -> Option<usize> {
    for (offset, c) in haystack.char_indices() {
        if c == needle {
            return Some(offset);
        }
    }
    None
}

unwrap

Option<T> 的 unwrap 函数返回 Some(T) 中的 T 类型值。若枚举值是 None，则会 panic。因此，该函数一般不被推荐使用。应该使用模式匹配对 None 值进行处理，或者使用下面三个函数：

  • unwrap_or – 返回 Some(T) 包含的值或者返回指定的默认值。
  • unwrap_or_else – 返回 Some(T) 包含的值或者通过一个闭包计算。
  • unwrap_or_default – 返回 Some(T) 包含的值或者 T 类型的默认值。

示例：查找文件名中的扩展名

fn extension_explicit(file_name: &str) -> Option<&str> {
    // 模式匹配
    match find(file_name, '.') {
        None => None,
        Some(i) => Some(&file_name[i+1..]),
    }
}
fn main() {
    // 模式匹配
    match extension_explicit("foo.rs") {
        None => println!("no extension"),
        Some(ext) => assert_eq!(ext, "rs"),
    }

    // 若遇到 `None`，则直接 panic
    let extension = extension_explicit("foo.rs").unwrap();
    println!("extension: {}", extension);

    // 若遇到 `None`，则返回指定的默认值：`rs`
    let extension = extension_explicit("foo").unwrap_or("rs");
    println!("extension: {}", extension);

    // 若遇到 `None`，则返回 &str 的默认值
    let extension = extension_explicit("foo").unwrap_or_default();
    println!("extension: {}", extension);
}

map

Option<T> 的 map 函数用来将一个枚举类型 Option<T> 映射为另外一个枚举类型 Option<U>。

map 的参数是一个闭包，用来指明如何映射。

示例：查找文件名中的扩展名

// 使用 `map` 函数可以替代模式匹配，这种方式更简洁
fn extension(file_name: &str) -> Option<&str> {
    // 若有值 `Some(T)` 则会执行 `map` 里的闭包，否则直接返回 `None`
    find(file_name, '.').map(|i| &file_name[i+1..])
}

和 map 类似的一些函数：

  • map_or – 若枚举值是 Some(T)，则运行闭包，否则返回指定的默认值
  • map_or_else – 该函数有两个闭包参数。若枚举值是 Some(T)，则运行第一个闭包，否则运行第二个闭包。

Result

Result<T, E> 是 Rust 标准库提供的一个枚举类型，其定义如下：

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

Result<T, E> 可以看做是 Option<T> 的升级版本，当值缺失时，Option<T> 使用 None 表示值不存在，而 Result<T, E> 使用 Err(E) 描述错误信息。Err(E) 中的 E 既可以是 Rust 中现有的类型，也可以是我们自定义的类型。

示例：在字符串 haystack 中查找 needle 字符，并返回该字符的索引

// 若未找到则返回 `Err(&str)` ，其中包含错误信息
fn find(haystack: &str, needle: char) -> Result<usize, &str> {
    for (offset, c) in haystack.char_indices() {
        if c == needle {
            return Ok(offset);
        }
    }
    Err("The specified character is not found")
}

unwrap 和 expect

Result<T, E> 的 unwrap 函数返回 Ok(T) 包含的值。若枚举值是 Err(E)，则会 panic。

unwrap 函数通常不推荐使用，应该使用模式匹配或者下面的函数来处理报错情况：

  • unwrap_or – 返回 Ok(T) 包含的值或者指定的默认值。
  • unwrap_or_else – 返回 Ok(T) 包含的值或者通过一个闭包计算。
  • unwrap_or_default – 返回 Ok(T) 包含的值或者 T 类型的默认值。

示例；查找文件名中的扩展名

fn extension_explicit(file_name: &str) -> Result<&str, &str> {
    match find(file_name, '.') {
        Err(e) => Err(e),
        Ok(i) => Ok(&file_name[i + 1..]),
    }
}
fn main() {
    // 模式匹配
    match extension_explicit("foo.rs") {
        Err(e) => println!("no extension: {}", e),
        Ok(ext) => assert_eq!(ext, "rs"),
    }

    // 若遇到 `Err`，则直接 panic
    let extension = extension_explicit("foo.rs").unwrap();
    println!("extension: {}", extension);

    // 若遇到 `Err`，则返回指定的默认值：`rs`
    let extension = extension_explicit("foo").unwrap_or("rs");
    println!("extension: {}", extension);

    // 若遇到 `Err`，则返回 &str 的默认值：空切片
    let extension = extension_explicit("foo").unwrap_or_default();
    println!("extension: {}", extension);
}

Result<T, E> 的 expect 函数与 unwrap 类似，该函数返回 Ok(T) 包含的值。若枚举值是 Err(E)，则会 panic ，除了会输出 Err(E) 中的内容，还会输出 expect 参数内容。

示例：

let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`

map

与 Option<T> 的 map 函数一样，Result<T, E> 的 map 函数可以简化模式匹配。

示例：

// 使用 map 函数替代模式匹配，这种方式更简洁
fn extension(file_name: &str) -> Result<&str, &str> {
    // 若返回值是 `Ok` 则会执行 `map` 里的闭包，否则直接返回 `Err`
    find(file_name, '.').map(|i| &file_name[i + 1..])
}

Result 别名

当 Result<T, E> 中的 T 或者 E 是固定的类型时，我们可以给 Result<T, E> 取一个别名，这样可以减少重复编码。

示例：标准库中的 std::io::Result

// 这是标准库 `io` 模块中给 `Result<T, std::io::Error>` 定义的一个别名
// 其中 `std::io::Error` 是 io 模块中定义的一个通用的错误类型
type Result<T> = Result<T, std::io::Error>;

// 使用别名，比如在 `std::io::Read` Trait 中
pub trait Read {
    // `Result<usize>` 等同于 `Result<usize, std::io::Error>`
    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
    fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize> { ... }
    fn is_read_vectored(&self) -> bool { ... }
    unsafe fn initializer(&self) -> Initializer { ... }
    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> { ... }
    fn read_to_string(&mut self, buf: &mut String) -> Result<usize> { ... }
    // `Result<()>` 等同于 `Result<(), std::io::Error>`
    fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> { ... }
    ...
}

传递错误

Rust 中的传递错误（Propagating Errors）类似于 Java 中的抛出异常，就是在当前函数中遇到错误时不做处理，而是将这个错误返回，让该函数的调用者决定如何处理该错误。

示例：将两个字符串解析为数值，并返回两个数值的乘积

use std::num::ParseIntError;

fn multiply(first_number_str: &str, second_number_str: &str) -> Result<i32, ParseIntError> {
    // 此处遇到错误，不做处理直接返回，把错误抛给上层该函数的调用者
    // 解析出错是因为传入该函数的参数有问题，应该由函数的调用者来处理
    let first_number = match first_number_str.parse::<i32>() {
        Ok(first_number) => first_number,
        Err(e) => return Err(e), // 这里使用 `return` 提前返回 `Err`
    };

    let second_number = match second_number_str.parse::<i32>() {
        Ok(second_number) => second_number,
        Err(e) => return Err(e),
    };

    Ok(first_number * second_number)
}

简化传递错误

使用 ? 操作符可以简化错误的传递，? 操作符的作用是：返回 Result<T, E> 中 T 类型的值，若遇到错误则返回 E。

示例：将两个字符串解析为数值，并返回两个数值的乘积

use std::num::ParseIntError;

fn multiply(first_number_str: &str, second_number_str: &str) -> Result<i32, ParseIntError> {
    let first_number = first_number_str.parse::<i32>()?;

    let second_number = second_number_str.parse::<i32>()?;

    Ok(first_number * second_number)
}

相关资料

The Rust Programming Language

Error Handling in Rust

Rust by Example

Rust Primer

花落花开99
关注
专栏目录
【Rust指南】错误的分类与传递|使用kind进行异常处理
微凉秋意的博客
09-25 2638
Rust 有一套独特的处理异常情况的机制，它并不像其它语言中的 try 机制那样简单。在Rust 中的错误分为两大类：可恢复错误和不可恢复错误。大多数编程语言用Exception（异常）类来表示错误。在 Rust 中没有 Exception。对于可恢复错误用类来处理，对于不可恢复错误使用panic!宏来处理。
抛出异常–缓慢而丑陋
最佳 Java 编程
05-17 203
这篇文章是关于历史经验以及最近应用的性能优化技术的。 几年前，我在特定的应用程序中发誓，我不得不发现隐藏在真正聪明的工程“技术”之下的无证行为。 它是一个典型的用于发票的单片Java EE应用程序。 最好忘记确切的代码，但是我记得开发人员已经找到了一种真正聪明的方法来控制业务流程。 流程的一部分通常是无休止的if-then-else混乱，但是使事情更加“令人兴奋”的是，这些检查的一些...
rust的cargo.toml下载依赖，出现ToolNotFound: Failed to find tool. Is `gcc.exe`错误
最新发布
m0_74838706的博客
06-21 621
（NTFS 卷上的短 ASCII 路径，无重音符号、无空格、无符号链接、无替换或网络驱动器、无 FAT）。（可选）有关安装程序的更多信息，例如命令行选项或如何验证安装程序的校验和和签名，请参阅。您可能需要安装一些工具（如 mingw-w64 GCC）来开始编译项目。安装 MSYS2 需要 64 位 Windows 10 或更新版本。终端窗口将显示以下输出。现在 MSYS2 已为您准备就绪，并且将启动。安装 MSYS2 后，它将通过 进行自我更新。来为 Windows 构建软件。
rust的错误和异常
fpcc的专栏
11-25 1781
一、错误和异常 在所有语言中，对程序运行不按照设计的“套路”出牌，都是错误。异常可以理解成程序的错误引发了运行的故障，甚至导致程序崩溃。正因为如此，对错误和异常的处理是所有语言都必须拥有的一个行为，无论是从语法层面还是从运行检查层面，都是无法回避的。同样，Rust也不能例外。 二、Rust中对错误的处理 在前面分析Result和Option时，分析过返回值和错误的处理。在Rust中，没有异常这一说，但为了和其它语言的描述保持一致，这里也叫做了异常的处理。Rust语言中有可恢复错误（recoverable）和
Rust从入门到实战系列八十七：传播错误的简写：? 运算符
wanmeijuhao的博客
03-03 826
作用的值相兼容的函数。Result 值之后的?如果值是 Err，Err 中的值将作为整个函数的返回值，就好像使用了 return 关键字一样，这样错误值就被传播给了调用者。幸运的是 main 函数也可以返回 Result，示例 9-12 中的代码来自示例 9-10 不过修改了 main 的返回值为 Result 并在结尾增加了一个 Ok (()) 作为返回值。main 函数是特殊的因为它是可执行程序的入口点和退出点，为了使程序能正常工作，其可以返回的类型是有限制的。
rust错误处理
神棍之路
07-13 751
错误处理 Rust 有一套独特的处理异常情况的机制，它并不像其它语言中的 try 机制那样简单。 首先，程序中一般会出现两种错误：可恢复错误和不可恢复错误。可恢复错误的典型案例是文件访问错误，如果访问一个文件失败，有可能是因为它正在被占用，是正常的，我们可以通过等待来解决。但还有一种错误是由编程中无法解决的逻辑错误导致的，例如访问数组末尾以外的位置。 大多数编程语言不区分这两种错误，并用 Exception （异常）类来表示错误。在 Rust 中没有 Exception。对于可恢复错误用 Result&lt
rust错误处理笔记项目
10-11
在 Rust 编程语言中，错误处理是一项至关重要的任务，因为 Rust 采取了一种严格的、类型安全的方式来处理可能出错的代码。这个“Rust 错误处理笔记项目”很可能是为了深入探讨 Rust 中的错误处理机制，以及如何优雅...
rust错误处理的好处
05-16
Rust的错误处理机制有许多好处，下面是其中几个： 1. 静态类型检查：Rust的错误处理机制是在编译时进行静态类型检查，这意味着在运行时出现的错误可以在编译时被捕获并修复，避免了一些难以发现的运行时错误。 2. ...
Rust基础 错误处理
zzzzzzelu的博客
10-19 1703
文章目录错误处理使用`panic!`宏使用`Result错误处理 Rust中将错误分为两类：可恢复的错误和不可恢复的错误。当遇见不可恢复的错误时，直接使用panic!宏使程序停止运行，当遇见可恢复的错误时，可以先使用枚举类型Result<T, E>封装错误，然后利用match {}对错误进行处理。在其它语言，比如Python中，所有错误都是可恢复的错误，使用try except对错误进行处理。 使用panic!宏 panic!的使用方法就和println!一样，如下： fn main() {
错误处理项目组-Rust开发
05-27
专注于定义和交流Rust的错误处理故事。 错误处理项目组欢迎来到错误处理项目组的存储库！ 我们专注于定义和交流Rust的错误处理故事。 这是我们用来组织工作的存储库。 有关我们的目标和当前范围的更多信息，请参考...
【Rust 基础篇】Rust 错误处理详解
繁依Fanyi的博客
07-07 1199
自定义错误类型是一种根据应用程序需求创建的特定错误类型。通过自定义错误类型，我们可以为不同的错误场景定义不同的错误类型，并在需要的地方使用这些类型。// 在发生错误的情况下返回自定义错误类型 Err(MyError :: SomeError) } fn main() {("操作成功") , Err(error) => match error {("遇到了 SomeError") , MyError :: AnotherError => println!
rust 案例_细说Rust错误处理
weixin_39633500的博客
12-24 2305
细说Rust错误处理1. 前言这篇文章写得比较长，全文读完大约需要15-20min，如果对Rust的错误处理不清楚或还有些许模糊的同学，请静下心来细细阅读。当读完该篇文章后，可以说对Rust的错误处理可以做到掌握自如。笔者花费较长篇幅来描述错误处理的来去，详细介绍其及一步步梳理内容，望大家能耐心读完后对大家有所帮助。当然，在写这篇文章之时，也借阅了大量互联网资料，详见链接见底部参考链接掌握好Rus...
快速了解：Rust 的错误处理
程序猿视角
08-02 1345
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中堆栈与并发
让我思考一下
02-09 3255
堆和栈 对不同语言，堆和栈是相通的，只不过，这里是以Rust语言为例，来理解堆和栈。宏观上讲，这两个术语是关于内存管理的。栈和堆是帮助你决定何时分配和释放内存的抽象（概念）。 首先先列出堆与栈的不同之处，没有列全： 栈非常快速，是一段连续的地址空间，并且是 Rust 默认分配内存的地方。不过这个分配位于函数调用的本地，并有大小限制（最大容量是系统设定好的，一般为几MM{M}大小左右）。 堆...
Rust安全之数值
大怀特的博客
08-25 1397
【代码】Rust安全之数值。
Rust从入门到实战系列一百二十五：修复错误处理
wanmeijuhao的博客
03-05 433
现在我们开始修复错误处理。回忆一下之前提到过如果 args vector 包含少于 3 个项并尝试访问 vector中索引 1 或索引 2 的值会造成程序 panic。尝试不带任何参数运行程序；这将看起来像这样：Runningindex out of bounds: the len is 1 but the index is 1 是一个针对程序员的错误信息，然而这并不能真正帮助终端用户理解发生了什么和他们应该做什么。现在就让我们修复它吧。改善错误信息。
Go语言中的错误处理
sanqima的专栏
10-03 428
    错误指程序中出现不正常的情况，从⽽导致程序⽆法正常执⾏。 error处理概述 Go语⾔中没有try…catch Go 语⾔通过内置的错误类型提供了⾮常简单的错误处理机制; 错误值可以存储在变量中，通过函数中返回; 如果⼀个函数或⽅法返回⼀个错误，按照惯例，它必须是函数返回的最后⼀个值; 处理错误的惯⽤⽅式是将返回的错误与nil进⾏⽐较; nil值表示没有发⽣错误，⽽⾮nil值表示出现错误; 如果不是nil，需打印输出错误。 error错误类型的本质 error本质上是⼀个接⼝类型，其中包含⼀个
Rust错误处理机制：优雅地管理错误
程序员Linc
11-21 810
在大型项目中，定义自己的错误类型是很常见的做法。这可以通过实现特征来完成。write!
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值