ToB企服应用市场:ToB评测及商务社交产业平台

标题: rust学习十、非常处置惩罚(错误处置惩罚) [打印本页]
作者: 莫张周刘王    时间: 2024-11-19 18:10
标题: rust学习十、非常处置惩罚(错误处置惩罚)
在册本中，中文译者翻译为错误,这是因为原文是"Error"。
但在许多语言中，都是书写为非常。
一、概述

rust的错误处置惩罚与众不同，前文已经提及：大家称为非常，它称为错误。

 
不可规复的错误，可以大要称为panic(恐慌)！ 太率性了....
那么我们的问题是：除了一些的确不可处置惩罚的非常，rust是否也和大部分语言那样利用try catch来捕获和跳过？
所谓的不可规复错误，实在也可以被try catch处置惩罚？
 
二、用panic!宏处置惩罚错误

不可规复错误发生的时候的通常表现：会打印出一个错误信息，展开并整理栈数据，然退却出
通过一个环境变量，可以让 Rust 在 panic 发生时打印调用堆栈（call stack）以便于定位 panic 的缘故起因.
 
两种退出方式
设置退出方式
Cargo.toml中设置，如下：
  1. [profile.release]
  2. panic = 'abort'
复制代码
上文中，panic还可以是设置为unwind，这是默认的
上例是release,如果想在调试的时候，那么可以添加profile.dev
更多的配置，可以参考 https://www.rustwiki.org.cn/zh-CN/cargo/index.html
 
触发方式
 
示例一、直接触发

 输出一大堆!!!
示例二、越界访问

输出太多，截取了比较又意义的部分：已经充足明白那里发生错误的。
毫无疑问，对于第二种情况，在其它语言种，一样平常简单try catch就可以处置惩罚了！
三、用Result处置惩罚可规复错误

Resutt是什么
一个枚举范例，类似Option。
有两个成员：Ok,Err
和Option的Some,None一样，Ok,Err也是可以直接利用，不需要书写前缀，因为它们都在prelude中导入了。
注意：prelude是序章的意思，可以理解为rust为每一个应用自动导入的部分。
 
处置惩罚Result，处置惩罚错误范例
由于Result是Option，以是，可以这样利用:
  1. use std::fs::File;
  2. use std::io::ErrorKind;
  4. fn main() {
  5.     let greeting_file_result = File::open("hello.txt");
  7.     let greeting_file = match greeting_file_result {
  8.         Ok(file) => file,
  9.         Err(error) => match error.kind() {
  10.             ErrorKind::NotFound => match File::create("hello.txt") {
  11.                 Ok(fc) => fc,
  12.                 Err(e) => panic!("Problem creating the file: {e:?}"),
  13.             },
  14.             other_error => {
  15.                 panic!("Problem opening the file: {other_error:?}");
  16.             }
  17.         },
  18.     };
  19. }
复制代码
 
大概
  1. use std::fs::File;
  2. use std::io::ErrorKind;
  4. fn main() {
  5.     let greeting_file = File::open("hello.txt").unwrap_or_else(|error| {
  6.         if error.kind() == ErrorKind::NotFound {
  7.             File::create("hello.txt").unwrap_or_else(|error| {
  8.                 panic!("Problem creating the file: {:?}", error);
  9.             })
  10.         } else {
  11.             panic!("Problem opening the file: {:?}", error);
  12.         }
  13.     });
  14. }
复制代码
 
失败的两种处置惩罚：unwrap,expect
  1. use std::fs::File;
  3. fn main() {
  4.     let greeting_file = File::open("hello.txt").unwrap();
  5.     let greeting_file2 = File::open("hello.txt")
  6.         .expect("hello.txt should be included in this project");
  7. }
复制代码
unwrap和expect的区别在于：后者会在触发错误的时候，直接打印参数值。
expect方法内部大要是这样的：
  1.     #[inline]
  2.     #[track_caller]
  3.     #[stable(feature = "result_expect", since = "1.4.0")]
  4.     pub fn expect(self, msg: &str) -> T
  5.     where
  6.         E: fmt::Debug,
  7.     {
  8.         match self {
  9.             Ok(t) => t,
  10.             Err(e) => unwrap_failed(msg, &e),
  11.         }
  12.     }
复制代码
 
逻辑：正常就返回值、不正常的则返回一个非常(不可规复的错误，退出)。
 
3.1传播错误-如那边理错误


在大部分的语言中，有两种方式：继续抛出大概捕获之后做其它处置惩罚，例如java就是这样处置惩罚的。
这个内容比较多，以是单独一个小章节说明：
通例处置惩罚-这个没有什么好说的。
利用?简化处置惩罚
 
1.正常代码
  1. use std::fs::File;
  2. use std::io::{self, Read};
  4. fn read_username_from_file() -> Result<String, io::Error> {
  5.     let username_file_result = File::open("hello.txt");
  7.     let mut username_file = match username_file_result {
  8.         Ok(file) => file,
  9.         Err(e) => return Err(e),
  10.     };
  12.     let mut username = String::new();
  14.     match username_file.read_to_string(&mut username) {
  15.         Ok(_) => Ok(username),
  16.         Err(e) => Err(e),
  17.     }
  18. }
复制代码
 
 
2.简化代码-1
  1. use std::fs::File;
  2. use std::io::{self, Read};
  4. fn read_username_from_file() -> Result<String, io::Error> {
  5.     let mut username_file = File::open("hello.txt")?;
  6.     let mut username = String::new();
  7.     username_file.read_to_string(&mut username)?;
  8.     Ok(username)
  9. }
复制代码
 
?这里表示 match xxxx 一段内容。如果出现非常，已经退出了。
 
3. 继续简化的代码_2
  1. use std::fs::File;
  2. use std::io::{self, Read};
  3. fn read_username_from_file() -> Result<String, io::Error> {
  4.     let mut username = String::new();
  5.     File::open("hello.txt")?.read_to_string(&mut username)?;
  6.     Ok(username)
  7. }
复制代码
 
这里主要利用链式写法简化了。毫无疑问，这个链式的还是比较受到欢迎的！！！
 
哪里不能用？
函数的返回值不同于？
最典型例子：
  1. use std::fs::File;
  3. fn main() {
  4.     let greeting_file = File::open("hello.txt")?;
  5. }
复制代码
 
这是因为main的返回范例是()    --  rust的什么都奇怪的很，虽然最内核大家都差不多。
让main支持?
有什么惊人之举吗？没有，就是修改返回范例。
  1. use std::error::Error;
  2. use std::fs::File;
  4. fn main() -> Result<(), Box<dyn Error>> {
  5.     let greeting_file = File::open("hello.txt")?;
  7.     Ok(())
  8. }
复制代码
 
四、要不要panic!宏

 原文说了一堆口水话，对于有经验的工程师而言，没有什么价值。略！
五、小结

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4