Rust在线运行

版本:

所属目录
点击了解高性能代码运行API
运行结果
教程手册
代码仓库
极速运行
终端运行
图形+终端

                        
以下是用户最新保存的代码
### VecDeque 复制测试 发布于:2024-04-23 09:37 ## 输入三个整数x,y,z,请把这三个数由小到大输出。 发布于:2024-03-03 11:45 # rust slice 发布于:2024-02-20 13:49 rust学习 发布于:2024-01-04 08:20 Rust hello world 发布于:2024-01-01 23:49 # Rust的常用迭代器适配器 ## map 可以用闭包将迭代器里的每个元素应用闭包里自定义的逻辑,从而生成处理后的元素迭代器,可以应用于数据处理与提取. ## filter 可以使用闭包过滤迭代器里的元素,只挑选出符合要求的元素组成新的迭代器返回。 ## fold ## zip ## chunks ## Chain ## all ## any ## windows ## cycle 发布于:2023-12-27 17:58 # 箱子、栈和堆 在 Rust 中,所有值默认都是栈分配的。通过创建 Box<T>,可以把值装箱(boxed)来使它在堆上分配。箱子(box,即 Box<T> 类型的实例)是一个智能指针,指向堆分配的 T 类型的值。当箱子离开作用域时,它的析构函数会被调用,内部的对象会被销毁,堆上分配的内存也会被释放。 被装箱的值可以使用 * 运算符进行解引用;这会移除掉一层装箱。 发布于:2023-12-27 17:40 测试rust的值域安全性 发布于:2023-12-12 09:52 书本的内容 发布于:2023-11-17 17:25 rust代码测试 发布于:2024-07-09 15:44 Learn Rust 发布于:2023-11-09 17:33 Rust学习使用 发布于:2023-05-21 11:21 exercise trait 发布于:2023-04-16 19:42 闭包的捕获 发布于:2023-01-28 16:32 Rust 结构体相关代价 发布于:2022-12-29 09:22 [package] name = "hello_rust" version = "0.1.0" authors = ["gress"] edition = "2018" [dependencies] anyhow= “0.1” 发布于:2022-12-06 20:09 第一个Rust程序 发布于:2022-06-20 00:11 开始学习rust 发布于:2022-05-30 13:51 enum sample 发布于:2022-02-24 15:03 泛型、特性与生命周期协同作战里的实例如何使用 发布于:2022-01-02 16:25 Rust第四章---所有权 发布于:2021-12-31 15:31 Rust第三章-常见编程概念 发布于:2021-12-31 13:16 Hello World Rust 发布于:2021-02-11 19:18 [更多]
显示目录

错误处理



学习嵌入式的绝佳套件,esp8266开源小电视成品,比自己去买开发板+屏幕还要便宜,省去了焊接不当搞坏的风险。 蜂鸣版+触控升级仅36元,更强的硬件、价格全网最低。

点击购买 固件广场

错误处理

Rust 有一套独特的处理异常情况的机制,它并不像其它语言中的 try 机制那样简单。

首先,程序中一般会出现两种错误:可恢复错误和不可恢复错误。

可恢复错误的典型案例是文件访问错误,如果访问一个文件失败,有可能是因为它正在被占用,是正常的,我们可以通过等待来解决。

但还有一种错误是由编程中无法解决的逻辑错误导致的,例如访问数组末尾以外的位置。

大多数编程语言不区分这两种错误,并用 Exception (异常)类来表示错误。在 Rust 中没有 Exception。

对于可恢复错误用 Result 类来处理,对于不可恢复错误使用 panic! 宏来处理。

不可恢复错误

本章以前没有专门介绍 Rust 宏的语法,但已经使用过了 println! 宏,因为这些宏的使用较为简单,所以暂时不需要彻底掌握它,我们可以用同样的方法先学会使用 panic! 宏的使用方法。

实例

fn main() {  
    panic!("error occured");  
    println!("Hello, Rust");  
}

运行结果:

thread 'main' panicked at 'error occured', src\\main.rs:3:5 
note: run with  \`RUST\_BACKTRACE=1\` environment variable to display a backtrace.

很显然,程序并不能如约运行到 println!("Hello, Rust") ,而是在 panic! 宏被调用时停止了运行。

不可恢复的错误一定会导致程序受到致命的打击而终止运行。

让我们注视错误输出的两行:

  • 第一行输出了 panic! 宏调用的位置以及其输出的错误信息。
  • 第二行是一句提示,翻译成中文就是"通过 `RUST_BACKTRACE=1` 环境变量运行以显示回溯"。接下来我们将介绍回溯(backtrace)。

紧接着刚才的例子,我们在 VSCode 中新建一个终端:

在新建的终端里设置环境变量(不同的终端方法不同,这里介绍两种主要的方法):

如果在 Windows 7 及以上的 Windows 系统版本中,默认使用的终端命令行是 Powershell,请使用以下命令:

$env:RUST\_BACKTRACE\=1  ; cargo run

如果你使用的是 Linux 或 macOS 等 UNIX 系统,一般情况下默认使用的是 bash 命令行,请使用以下命令:

RUST\_BACKTRACE\=1 cargo run

然后,你会看到以下文字:

thread 'main' panicked at 'error occured', src\main.rs:3:5
stack backtrace:
  ...
  11: greeting::main
             at .\src\main.rs:3
  ...

回溯是不可恢复错误的另一种处理方式,它会展开运行的栈并输出所有的信息,然后程序依然会退出。上面的省略号省略了大量的输出信息,我们可以找到我们编写的 panic! 宏触发的错误。

可恢复的错误

此概念十分类似于 Java 编程语言中的异常。实际上在 C 语言中我们就常常将函数返回值设置成整数来表达函数遇到的错误,在 Rust 中通过 Result 枚举类作返回值来进行异常表达:

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

在 Rust 标准库中可能产生异常的函数的返回值都是 Result 类型的。例如:当我们尝试打开一个文件时:

实例

use std::fs::File;  

fn main() {  
    let f \= File::open("hello.txt");  
    match f {  
        Ok(file) \=> {  
            println!("File opened successfully.");  
        },  
        Err(err) \=> {  
            println!("Failed to open the file.");  
        }  
    }  
}

如果 hello.txt 文件不存在,会打印 "Failed to open the file."

当然,我们在枚举类章节讲到的 if let 语法可以简化 match 语法块:

实例

use std::fs::File;  

fn main() {  
    let f \= File::open("hello.txt");  
    if let Ok(file) \= f {  
        println!("File opened successfully.");  
    } else {  
        println!("Failed to open the file.");  
    }  
}  

如果想使一个可恢复错误按不可恢复错误处理,Result 类提供了两个办法:unwrap() 和 expect(message: &str) :

实例
--

use std::fs::File;

fn main() {
let f1 \= File::open("hello.txt").unwrap();
let f2 \= File::open("hello.txt").expect("Failed to open.");
}

这段程序相当于在 Result 为 Err 时调用 panic! 宏。两者的区别在于 expect 能够向 panic! 宏发送一段指定的错误信息。

### 可恢复的错误的传递

之前所讲的是接收到错误的处理方式,但是如果我们自己编写一个函数在遇到错误时想传递出去怎么办呢?

实例
--

fn f(i: i32) -> Result {
if i >= 0 { Ok(i) }
else { Err(false) }
}

fn main() {
let r \= f(10000);
if let Ok(v) \= r {
println!("Ok: f(-1) = {}", v);
} else {
println!("Err");
}
}

运行结果:

Ok: f(-1) \= 10000

这段程序中函数 f 是错误的根源,现在我们再写一个传递错误的函数 g :

实例
--

fn g(i: i32) -> Result {
let t \= f(i);
return match t {
Ok(i) \=> Ok(i),
Err(b) \=> Err(b)
};
}

函数 g 传递了函数 f 可能出现的错误(这里的 g 只是一个简单的例子,实际上传递错误的函数一般还包含很多其它操作)。

这样写有些冗长,Rust 中可以在 Result 对象后添加 ? 操作符将同类的 Err 直接传递出去:

实例
--

fn f(i: i32) -> Result {
if i >= 0 { Ok(i) }
else { Err(false) }
}

fn g(i: i32) -> Result {
let t \= f(i)?;
Ok(t) // 因为确定 t 不是 Err, t 在这里已经是 i32 类型
}

fn main() {
let r \= g(10000);
if let Ok(v) \= r {
println!("Ok: g(10000) = {}", v);
} else {
println!("Err");
}
}

运行结果:

Ok: g(10000) \= 10000

? 符的实际作用是将 Result 类非异常的值直接取出,如果有异常就将异常 Result 返回出去。所以,? 符仅用于返回值类型为 Result<T, E> 的函数,其中 E 类型必须和 ? 所处理的 Result 的 E 类型一致。

* * *

kind 方法
-------

到此为止,Rust 似乎没有像 try 块一样可以令任何位置发生的同类异常都直接得到相同的解决的语法,但这样并不意味着 Rust 实现不了:我们完全可以把 try 块在独立的函数中实现,将所有的异常都传递出去解决。实际上这才是一个分化良好的程序应当遵循的编程方法:应该注重独立功能的完整性。

但是这样需要判断 Result 的 Err 类型,获取 Err 类型的函数是 kind()。

实例
--

use std::io;
use std::io::Read;
use std::fs::File;

fn read_text_from_file(path: &str) -> Result {
let mut f \= File::open(path)?;
let mut s \= String::new();
f.read_to_string(&mut s)?;
Ok(s)
}

fn main() {
let str_file \= read_text_from_file("hello.txt");
match str_file {
Ok(s) \=> println!("{}", s),
Err(e) \=> {
match e.kind() {
io::ErrorKind::NotFound \=> {
println!("No such file");
},
_ \=> {
println!("Cannot read the file");
}
}
}
}
}

运行结果:

No such file ```

由JSRUN为你提供的Rust在线运行、在线编译工具
        JSRUN提供的Rust 在线运行,Rust 在线运行工具,基于linux操作系统环境提供线上编译和线上运行,具有运行快速,运行结果与常用开发、生产环境保持一致的特点。
yout