学习 Rust 的第十五天：如何处理程序异常信息

soragui2024-05-01 14:15

大家好，

在过去的三天里，我们已经完成了 Rust 的三个常见集合，今天我们将学习有关 Rust 中错误处理的所有内容。

引言

错误处理基本上意味着如何处理一些对你的程序来说不是最佳选择的情况，有一些可以优雅处理的错误，如果错误无法被处理/从中恢复，我们可以调用panic宏并有意地使我们的程序崩溃。我们还将看一下回溯...

Panic 宏

当我们想要我们的程序有意崩溃时，就会使用 panic 宏。如果一个错误无法被优雅地处理或者程序无法从错误中恢复，我们可以通过以下语法调用 panic 宏：

rust 复制代码 
panic!(error_message: &str);

示例：

rust 复制代码 
fn main(){  
  panic!("This is a test panic");  
}

输出：

bash 复制代码 
thread 'main' panicked at src/main.rs:2:3:  
This is a test panic  
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

panic 消息显示我们可以通过运行带有 RUST_BACKTRACE=1 环境变量的程序来获取回溯信息

什么是回溯？

回溯是代码崩溃前调用的所有函数的跟踪，让我们用一个稍微准确的例子来看看：

rust 复制代码 
fn main(){  
    a();  
}  
  
fn a(){  
    b();  
}  
fn b(){  
    panic!("Function panicked");  
}

输出：

bash 复制代码 
thread 'main' panicked at src/main.rs:9:5:  
Function panicked  
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

带有 RUST_BACKTRACE=1 的输出：

bash 复制代码 
thread 'main' panicked at src/main.rs:9:5:  
Function panicked  
stack backtrace:  
   0: rust_begin_unwind  
             at /rustc/07dca489ac2d933c78d3c5158e3f43beefeb02ce/library/std/src/panicking.rs:645:5  
   1: core::panicking::panic_fmt  
             at /rustc/07dca489ac2d933c78d3c5158e3f43beefeb02ce/library/core/src/panicking.rs:72:14  
   2: error_handling::b  
             at ./src/main.rs:9:5  
   3: error_handling::a  
             at ./src/main.rs:6:5  
   4: error_handling::main  
             at ./src/main.rs:2:5  
   5: core::ops::function::FnOnce::call_once  
             at /rustc/07dca489ac2d933c78d3c5158e3f43beefeb02ce/library/core/src/ops/function.rs:250:5  
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

在这个例子中，我们可以看到，main() 调用了函数 a()，然后 a() 调用了 b()，后者导致程序崩溃，我们可以清楚地通过回溯了解代码中发生了什么。

Result 枚举

Rust 中的 Result 枚举通过提供一种表示操作成功或失败的方式来简化错误处理，例如，打开一个文件如果文件不存在可能会失败，这将导致一个错误。

Result 枚举看起来像这样。

rust 复制代码 
match Result(  
  Ok(arguments) => {},  
  Err(error) => {},  
);

让我们通过一个例子更好地了解一下...

rust 复制代码 
use std::fs::File;  
use std::io::prelude::*;  
  
fn main() {  
    // 尝试打开一个文件  
    match File::create("example.txt") {  
        Ok(mut file) => {  
            // 文件创建成功，向其中写入内容  
            if let Err(e) = file.write_all(b"Hello, World!") {  
                println!("Failed to write to file: {}", e);  
            } else {  
                println!("Data successfully written to file.");  
            }  
        }  
        Err(e) => {  
            // 创建文件失败，处理错误  
            println!("Failed to create file: {}", e);  
        }  
    }  
}
  • 该代码尝试使用 File::create() 创建一个名为 "example.txt" 的文件。
  • 它使用 match 语句匹配文件创建操作的结果。
  • 如果文件成功创建 (Ok(mut file))，则继续将 "Hello, World!" 写入文件。
  • 如果写入文件失败 (Err(e))，则打印错误消息。
  • 如果创建文件失败 (Err(e))，则打印错误消息，指示失败的原因。

输出：

Data successfully written to file.

example.txt：

Hello, World!

除了使用 match 表达式，我们也可以调用 unwrap() 或 expect() 方法来执行此操作。

unwrap() 方法用于从 Result 枚举中获取值，如果遇到 Err，则会发生 panic，而 expect() 提供了类似的功能，但允许在失败时提供自定义错误消息。

错误传播

在 Rust 中，错误传播是通过将错误沿着调用堆栈向上传播来完成的，使用 Result 类型，从而允许模块化地处理错误并保留抽象级别。它鼓励集中式错误处理，允许在整个程序中使用统一的策略，并通过提供有关问题原因的上下文信息来改善调试。这种策略确保了优雅的失败处理，并有助于构建强大且可维护的软件。

让我们看一个例子

rust 复制代码 
use std::fs::File;  
use std::io::{self, Write};  
  
fn write_to_file(data: &[u8]) -> io::Result<()> {  
    let mut file = match File::create("example.txt") {  
        Ok(file) => file,  
        Err(e) => return Err(e),  


    };  
  
    match file.write_all(data) {  
        Ok(_) => Ok(()),  
        Err(e) => Err(e),  
    }  
}  
  
fn main() {  
    let data = b"Hello, World!";  
    match write_to_file(data) {  
        Ok(()) => println!("Data successfully written to file."),  
        Err(e) => println!("Failed to write to file: {}", e),  
    }  
}
  • write_to_file 函数尝试创建一个名为 "example.txt" 的文件并向其写入数据。
  • 在 write_to_file 内部，使用 match 语句处理 File::create 的结果。如果文件创建成功，则将文件句柄存储在 file 中。如果失败，则提前返回错误。
  • 使用另一个 match 语句处理 write_all 的结果。如果写入操作成功，则返回 Ok(())。如果失败，则返回错误。
  • 在 main 函数中，再次匹配 write_to_file 的结果，以确定操作是否成功。

通过使用 ? 操作符，此代码可以变得更短，更易读。

在 Rust 中，? 操作符是错误传播的一种简写。它可以在返回 Result 类型的函数内部使用，通过自动解包 Ok 变体并返回包含的值或传播 Err 变体，简化错误处理。

rust 复制代码 
use std::fs::File;  
use std::io::{self, Write};  
  
fn write_to_file(data: &[u8]) -> io::Result<()> {  
    let mut file = File::create("example.txt")?;  
    file.write_all(data)?;  
    Ok(())  
}  
  
fn main() -> io::Result<()> {  
    let data = b"Hello, World!";  
    write_to_file(data)?;  
    println!("Data successfully written to file.");  
    Ok(())  
}
  • write_to_file 函数尝试创建一个名为 "example.txt" 的文件并向其写入数据。
  • 在每个潜在引发错误的操作 (File::create 和 write_all) 之后使用 ? 操作符。如果在任何步骤中发生错误，它将被传播到调用堆栈上，函数将提前返回该错误。
  • 在 main 函数中也使用了错误传播，允许优雅地处理来自 write_to_file 的任何错误，如果成功，则打印成功消息。

总的来说，? 操作符通过减少样板代码和提高可读性来简化 Rust 代码中的错误处理。

用于错误处理的自定义类型

我们在本系列开始时创建了一个猜数字游戏。

在那个游戏中，我们只是从用户那里获取数字而没有任何形式的验证，尽管我们的猜测范围是 1..=100。用户可以输入任何数字，所以让我们解决这个问题？

rust 复制代码 
pub struct Guess{  
  value: i32,  
}  
  
impl Guess {  
  pub fn new(value: i32) -> Guess{  
    if value < 1 || value > 100 {  
      panic!("Value must be between 1 to 100, got {}", value);  
    }  
    Guess{ value }  
  }  
    
  pub fn value(&self) -> i32{  
    self.value  
  }  
}

现在我们可以使用这个来改进我们的猜数字游戏，让我们将其集成到代码中...

rust 复制代码 
use std::io;  
use std::cmp::Ordering;  
use rand::Rng;  
  
pub struct Guess{  
  value: i32,  
}  
  
impl Guess {  
  pub fn new(value: i32) -> Guess{  
    if value < 1 || value > 100 {  
      panic!("Value must be between 1 to 100, got {}", value);  
    }  
    Guess{ value }  
  }  
  
  pub fn value(&self) -> i32{  
    self.value  
  }  
}  
  
fn main() {  
    println!("Guess the number!");  
  
    let secret_number = rand::thread_rng().gen_range(1..=100);  
  
    loop {  
        println!("Please input your guess");  
  
        let mut guess = String::new();  
  
        io::stdin().read_line(&mut guess).expect("Failed to read line");  
  
        let guess: i32 = match guess.trim().parse() {  
            Ok(num) => num,  
            Err(_) => continue,  
  
        };  
  
        let guess: Guess = Guess::new(guess);  
  
        println!("Your guess: {}", guess.value);  
  
        match guess.value().cmp(&secret_number) {  
            Ordering::Less => println!("Too small!"),  
            Ordering::Greater => println!("Too big!"),  
            Ordering::Equal => {  
                println!("You win!");  
                break;  
            },  
        }  
    }  
}

输出：

rust 复制代码 
Guess the number!  
Please input your guess  
100  
Your guess: 100  
Too big!  
Please input your guess  
291  
thread 'main' panicked at src/main.rs:12:7:  
Value must be between 1 to 100, got 291

结论

总的来说，错误管理是 Rust 编程的重要组成部分，允许开发人员优雅地处理意外发生的情况。Rust 具有各种错误管理特性，包括用于有意程序崩溃的 panic 宏，用于描述操作结果的 Result 枚举以及用于简化错误传播的? 操作符。使用这些方法和定制的错误类型，开发人员可以创建出强大且可靠的软件，这些软件可以正确地处理错误。了解错误处理系统的 Rust 开发人员可以构建更安全、更易于维护的代码，从而提高其程序的总体质量和可靠性。

相关推荐
香菜大丸7 分钟前
链表的归并排序
数据结构·算法·链表
jrrz08287 分钟前
LeetCode 热题100（七）【链表】（1）
数据结构·c++·算法·leetcode·链表
oliveira-time19 分钟前
golang学习2
算法
@小博的博客35 分钟前
C++初阶学习第十弹——深入讲解vector的迭代器失效
数据结构·c++·学习
南宫生1 小时前
贪心算法习题其四【力扣】【算法学习day.21】
学习·算法·leetcode·链表·贪心算法
老猿讲编程2 小时前
用示例来看C2Rust工具的使用和功能介绍
rust
金庆2 小时前
How to set_default() using config-rs crate
rust·config·set_default·valuekind
懒惰才能让科技进步2 小时前
从零学习大模型（十二）-----基于梯度的重要性剪枝（Gradient-based Pruning）
人工智能·深度学习·学习·算法·chatgpt·transformer·剪枝
Ni-Guvara2 小时前
函数对象笔记
c++·算法
love_and_hope2 小时前
Pytorch学习--神经网络--搭建小实战（手撕CIFAR 10 model structure）和 Sequential 的使用
人工智能·pytorch·python·深度学习·学习
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解