panic!

Rust 中最简单的错误处理方式就是使用 panic。它会打印出一条错误信息并打印出栈调用情况，最终结束当前线程:

  • 若 panic 发生在 main 线程，那程序会随之退出

  • 如果是在生成的( spawn )子线程中发生 panic, 那么当前的线程会结束，但是程序依然会继续运行

  • 🌟🌟

2. // 填空
3. fn drink(beverage: &str) {
4. if beverage == "lemonade" {
5. println!("Success!");
6. // 实现下面的代码
7. __
8. }

10. println!("Exercise Failed if printing out this line!");
11. }

13. fn main() {
14. drink(__);

16. println!("Exercise Failed if printing out this line!");
17. }

常见的 panic

  1. 🌟🌟
1. // 修复所有的 panic，让代码工作
2. fn main() {
3. assert_eq!("abc".as_bytes(), [96, 97, 98]);

5. let v = vec![1, 2, 3];
6. let ele = v[3];
7. let ele = v.get(3).unwrap();

9. // 大部分时候编译器是可以帮我们提前发现溢出错误，并阻止编译通过。但是也有一些时候，这种溢出问题直到运行期才会出现
10. let v = production_rate_per_hour(2);

12. divide(15, 0);

14. println!("Success!")
15. }

17. fn divide(x:u8, y:u8) {
18. println!("{}", x / y)
19. }

21. fn production_rate_per_hour(speed: u8) -> f64 {
22. let cph: u8 = 221;
23. match speed {
24. 1..=4 => (speed * cph) as f64,
25. 5..=8 => (speed * cph) as f64 * 0.9,
26. 9..=10 => (speed * cph) as f64 * 0.77,
27. _ => 0 as f64,
28. }
29. }

31. pub fn working_items_per_minute(speed: u8) -> u32 {
32. (production_rate_per_hour(speed) / 60 as f64) as u32
33. }

详细的栈调用信息

默认情况下，栈调用只会展示最基本的信息:

1. thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
2. note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

但是有时候，我们还希望获取更详细的信息:

  1. 🌟
1. ## 填空以打印全部的调用栈
2. ## 提示: 你可以在之前的默认 panic 信息中找到相关线索
3. $ __ cargo run
4. thread 'main' panicked at 'assertion failed: `(left == right)`
5. left: `[97, 98, 99]`,
6. right: `[96, 97, 98]`', src/main.rs:3:5
7. stack backtrace:
8. 0: rust_begin_unwind
9. at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/std/src/panicking.rs:498:5
10. 1: core::panicking::panic_fmt
11. at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/core/src/panicking.rs:116:14
12. 2: core::panicking::assert_failed_inner
13. 3: core::panicking::assert_failed
14. at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/core/src/panicking.rs:154:5
15. 4: study_cargo::main
16. at ./src/main.rs:3:5
17. 5: core::ops::function::FnOnce::call_once
18. at /rustc/9d1b2106e23b1abd32fce1f17267604a5102f57a/library/core/src/ops/function.rs:227:5
19. note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.

unwinding 和 abort

当出现 panic! 时，程序提供了两种方式来处理终止流程：栈展开和直接终止。

其中，默认的方式就是 栈展开，这意味着 Rust 会回溯栈上数据和函数调用，因此也意味着更多的善后工作，好处是可以给出充分的报错信息和栈调用信息，便于事后的问题复盘。直接终止，顾名思义，不清理数据就直接退出程序，善后工作交与操作系统来负责。

对于绝大多数用户，使用默认选择是最好的，但是当你关心最终编译出的二进制可执行文件大小时，那么可以尝试去使用直接终止的方式，例如下面的配置修改 Cargo.toml 文件，实现在 release 模式下遇到 panic 直接终止：

1. #![allow(unused)]
2. fn main() {
3. [profile.release]
4. panic = 'abort'
5. }

你可以在这里找到答案(在 solutions 路径下)