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

embedded/2024/10/22 13:44:54/

大家好，

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

引言

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

Panic 宏

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

rust">panic!(error_message: &str);

示例：

rust">fn main(){  panic!("This is a test panic");  
}

输出：

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");  
}

输出：

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 的输出：


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


http://www.ppmy.cn/embedded/30643.html

相关文章

spring boot 启动流程详解

spring boot 启动流程详解

主启动类 SpringBootApplication MapperScan("com.example.mapper") public class StableBootApplication {public static void main(String[] args) {SpringApplication.run(StableBootApplication.class,args);} }SpringApplication类中有个静态run()方法&#xf…
阅读更多...
常用设计模式

常用设计模式

单例模式 一个类只能创建一个对象&#xff0c;即单例模式&#xff0c;该设计模式可以保证系统中该类只有⼀个实例&#xff0c;并提供⼀个访问它的全局访问点&#xff0c;该实例被所有程序模块共享。比如在某个服务器程序中&#xff0c;该服务器的配置信息存放在⼀个文件中&…
阅读更多...
软件测试面试之常见编程算法笔试题

软件测试面试之常见编程算法笔试题

1.请写出冒泡排序。 #冒泡排序&#xff1a;n*n def bubbleSort(array):maxindex len(array)-1maxValue array[maxindex]k0while maxindex:for i in range(1,maxindex):if array[i-1]>array[i]:temp array[i]array[i] array[i-1]array[i-1] tempk1maxindex -1print(k)re…
阅读更多...
pytorch笔记：ModuleDict

pytorch笔记：ModuleDict

1 介绍 在 PyTorch 中&#xff0c;nn.ModuleDict 是一个方便的容器&#xff0c;用于存储一组子模块&#xff08;即 nn.Module 对象&#xff09;的字典这个容器主要用于动态地管理多个模块&#xff0c;并通过键来访问它们&#xff0c;类似于 Python 的字典 2 特点 组织性 nn…
阅读更多...
【ARM Cache 系列文章 11.2 -- ARM Cache 组相联映射】

【ARM Cache 系列文章 11.2 -- ARM Cache 组相联映射】

请阅读【ARM Cache 系列文章专栏导读】 文章目录 Cache 组相联映射组相联映射原理多路组相连缓存的优势多路组相连缓存的代价关联度&#xff08;Associativity&#xff09; 上篇文章&#xff1a;【ARM Cache 系列文章 11.1 – ARM Cache 全相连 详细介绍】 Cache 组相联映射 A…
阅读更多...
【QA】Java集合的常见遍历方式

【QA】Java集合的常见遍历方式

前言 本文主要讲述Java集合常见的遍历方式。 通用遍历方式 | Collection集合 迭代器Iterator遍历 Collection<Student> c new ArrayList<>();c.add(new Student("张三", 23)); c.add(new Student("李四", 24)); c.add(new Student("…
阅读更多...
【Java笔记】CAS比较的是什么+交换的是什么+自旋到啥时候

【Java笔记】CAS比较的是什么+交换的是什么+自旋到啥时候

文章目录 什么是CASCAS原理CAS的原子性CAS的三个问题问题一&#xff1a;ABA解决方法 问题二&#xff1a;CPU开销过大解决方法 问题三&#xff1a;不能保证代码块的原子性解决方法 Reference 之前看CAS一致迷迷糊糊的&#xff0c;知道它通过自旋来避免多线程冲突&#xff0c;然后…
阅读更多...
MATLAB 微积分

MATLAB 微积分

MATLAB 微积分 MATLAB提供了多种方法来解决微分和积分问题&#xff0c;求解任意程度的微分方程式以及计算极限。最重要的是&#xff0c;您可以轻松求解复杂函数的图&#xff0c;并通过求解原始函数及其导数来检查图上的最大值&#xff0c;最小值和其他文具点。 本章将讨论微…
阅读更多...
最新文章

Copyright @ 2022~2023