学习 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 开发人员可以构建更安全、更易于维护的代码，从而提高其程序的总体质量和可靠性。

相关推荐
XH华3 小时前
初识C语言之二维数组(下)
c语言·算法
南宫生3 小时前
力扣-图论-17【算法学习day.67】
java·学习·算法·leetcode·图论
不想当程序猿_3 小时前
【蓝桥杯每日一题】求和——前缀和
算法·前缀和·蓝桥杯
sanguine__3 小时前
Web APIs学习 （操作DOM BOM）
学习
落魄君子3 小时前
GA-BP分类-遗传算法（Genetic Algorithm）和反向传播算法（Backpropagation）
算法·分类·数据挖掘
菜鸡中的奋斗鸡→挣扎鸡4 小时前
滑动窗口 + 算法复习
数据结构·算法
Lenyiin4 小时前
第146场双周赛：统计符合条件长度为3的子数组数目、统计异或值为给定值的路径数目、判断网格图能否被切割成块、唯一中间众数子序列 Ⅰ
c++·算法·leetcode·周赛·lenyiin
郭wes代码4 小时前
Cmd命令大全（万字详细版）
python·算法·小程序
scan7244 小时前
LILAC采样算法
人工智能·算法·机器学习
菌菌的快乐生活4 小时前
理解支持向量机
算法·机器学习·支持向量机
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程