Rust编程语言之错误处理

一、panic! 不可恢复的错误

Rust 错误处理概述

• Rust 的可靠性：错误处理
  • 大部分情况下：在编译时提示错误，并处理
• 错误的分类：
  • 可恢复
  • 例如文件未找到，可再次尝试
  • 不可恢复
  • bug，例如访问的索引超出范围
• Rust没有类似异常的机制
  • 可恢复错误：Result<T, E>
  • 不可恢复：panic! 宏

不可恢复的错误与 panic

• 当 panic! 宏执行：
  • 你的程序会打印一个错误信息
  • 展开(unwind)、清理调用栈(Stack)
  • 退出程序

为应对 panic，展开或中止(abort) 调用栈

• 默认情况下，当 panic 发生：
  • 程序展开调用栈（工作量大）
  • Rust 沿着调用栈往回走
  • 清理每个遇到的函数中的数据
  • 或立即中止调用栈：
  • 不进行清理，直接停止程序
  • 内存需要 OS 进行清理
• 想让二进制文件更小，把设置从“展开”改为“中止”：
  • 在 Cargo.toml 中适当的 profile 部分设置：
  • panic = 'abort'

例子：Cargo.toml 文件

[package]
name = "vector_demo"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

[profile.release]
panic = 'abort'

例子：src/main.rs 文件

fn main() {
  // panic!("crash and burn");

  let v = vec![1, 2, 3];

  v[99]; // panic
}

使用 panic! 产生的回溯信息

• panic! 可能出现在：
  • 我们写的代码中
  • 我们所依赖的代码中
• 可通过调用 panic! 的函数的回溯信息来定位引起问题的代码
• 通过设置环境变量 RUST_BACKTRACE 可得到回溯信息
• 为了获取带有调试信息的回溯，必须启用调试符号（不带 --release）

二、Result 枚举与可恢复的错误（上）

Result 枚举

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

• T：操作成功情况下，Ok 变体里返回的数据的类型
• E：操作失败情况下，Err 变体里返回的错误的类型

use std::fs::File

fn main() {
  let f = File::open("hello.txt");
}

处理 Result 的一种方式：match 表达式

• 和 Option 枚举一样，Result 及其变体也是由 prelude 带入作用域

use std::fs::File

fn main() {
  let f = File::open("hello.txt");

  let f = match f {
    Ok(file) => file,
    Err(error) => {
      panic!("Error opening file {:?}", error)
    }
  };
}

匹配不同的错误

use std::fs::File

fn main() {
  let f = File::open("hello.txt");

  let f = match f {
    Ok(file) => file,
    Err(error) => match error.kind() {
      ErrorKind::NotFound => match File::create("hello.txt") {
        Ok(fc) => fc,
        Err(e) => panic!("Error creating file: {:?}", e),
      },
      other_error = panic!("Error opening the file: {:?}", other_error),
    },
  };
}

• 上例中使用了很多 match ...
• Match 很有用，但是很原始
• 闭包(closure)。Result<T, E> 有很多方法：
  • 它们接收闭包作为参数
  • 使用 match 实现
  • 使用这些方法会让代码更简洁

use std::fs::File

fn main() {
  let f = File::open("hello.txt").unwrap_or_else(|error| {
    if error.kind() == ErrorKind::NotFound {
      File::create("hello.txt").unwrap_or_else(|error| {
        panic!("Error creating file: {:?}", error);
      })
    } else {
      panic!("Error opening the file: {:?}", error);
    }
  });
}

unwrap

• unwrap：match 表达式的一个快捷方式：
  • 如果 Result 结果是 Ok，返回 Ok 里面的值
  • 如果 Result 结构是 Err，调用 panic! 宏

use std::fs::File

fn main() {
  let f = File::open("hello.txt");

  let f = match f {
    Ok(file) => file,
    Err(error) => {
      panic!("Error opening file {:?}", error)
    }
  };

  let f = File::open("hello.txt").unwrap();  // 错误信息不可自定义
}

expect

• expect：和 unwrap 类似，但可指定错误信息

use std::fs::File

fn main() {
  let f = File::open("hello.txt").expect("无法打开文件 hello.txt");  
}

三、Result 枚举与可恢复的错误（下）

传播错误

• 在函数处处理错误
• 将错误返回给调用者

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

fn read_username_from_file() -> Result<String, io::Error> {
  let f = File::open("hello.txt");

  let mut f = match f {
    Ok(file) => file,
    Err(e) => return Err(e),
  };

  let mut s = String::new();
  match f.read_to_string(&mut s) {
    Ok(_) => Ok(s),
    Err(e) => Err(e),
  }
}

fn main() {
  let result = read_username_from_file();
}

? 运算符

• ？ 运算符：传播错误的一种快捷方式

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

fn read_username_from_file() -> Result<String, io::Error> {
  let mut f = File::open("hello.txt")?;

  let mut s = String::new();
  f.read_to_string(&mut s)?;
  Ok(s)
}

fn main() {
  let result = read_username_from_file();
}

• 如果 Result 是 Ok：Ok 中的值就是表达式的结果，然后继续执行程序
• 如果 Result 是 Err：Err 就是整个函数的返回值，就像使用了 return

? 与 from 函数

• Trait std::convert::From 上的 from 函数：

  • 用于错误之间的转换

• 被 ？ 所应用的错误，会隐式的被 from 函数处理

• 当 ？ 调用 from 函数时：

  • 它所接收的错误类型会被转化为当前函数返回类型所定义的错误类型

• 用于：针对不同错误原因，返回同一种错误类型

  • 只要每个错误类型实现了转换为所返回的错误类型的from函数

• 链式调用

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

fn read_username_from_file() -> Result<String, io::Error> {
  let mut s = String::new();
  File::open("hello.txt")?.read_to_string(&mut s)?;
  Ok(s)
}

fn main() {
  let result = read_username_from_file();
}

? 运算符只能用于返回 Result 的函数

use std::fs::File;

fn main() {
  let f = File::open("hello.txt")?; // 报错 
}

? 运算符与 main 函数

• main 函数返回类型是: ()
• main 函数的返回类型也可以是： Result<T, E>

use std::error::Error;
use std::fs::File;

fn main() -> Result<(), Box<dyn Error>> {
  let f = File::open("hello.txt")?;
  Ok(())
}

• Box<dyn Error> 是 Trait 对象：
  • 简单理解：“任何可能得错误类型”

四、什么时候应该用 panic

总体原则

• 在定义一个可能失败的函数时，优先考虑返回 Result
• 否则就 panic!

编写示例、原型代码、测试

• 可以使用panic!
  • 演示某些概念：unwrap
  • 原型代码：unwrap、expect
  • 测试：unwrap、expect

有时你比编译器掌握更多的信息

• 你可以确定 Result 就是 Ok：unwrap

use std::net::IpAddr;

fn main() {
  let home: IpAddr = "127.0.0.1".parse().unwrap();
}

错误处理的指导性建议

• 当代码最终可能处于损坏状态时，最号使用 panic!
• 损坏状态(Bad state)：某些假设、保证、约定或不可变性被打破
  • 例如非法的值、矛盾的值或空缺的值被传入代码
  • 以及下列中的一条：
  • 这种损坏状态并不是预期能够偶尔发生的事情
  • 在此之后，您的代码如果处于这种损坏状态就无法运行
  • 在您使用的类型中没有一个好的方法来将这些信息（处于损坏状态）进行编码

场景建议

• 调用你的代码，传入无意义的参数值：panic!
• 调用外部不可控代码，返回非法状态，你无法修复：panic!
• 如果失败是可预期的：Result
• 当你的代码对值进行操作，首先应该验证这些值：panic!

为验证创建自定义类型

fn main() {
  loop {
    // ...

    let guess = "32";
    let guess: i32 = match guess.trim().parse() {
      Ok(num) => num,
      Err(_) => continue,
    };

    if guess < 1 || guess > 100 {
      println!("The secret number will be between 1 and 100.");
      continue;
    }

    // ...
  }
}

• 创建新的类型，把验证逻辑放在构造实例的函数里

pub struct Guess {
  value: i32,
}

impl Guess {
  pub fn new(value: i32) -> Guess {
    if value < 1 || value >100 {
      panic!("Guess value must be between 1 and 100, got {}", value);
    }

    Guess {value}
  }

  pub fn value(&self) -> i32 {
    self.value
  }
}

fn main() {
  loop {
    // ...

    let guess = "32";
    let guess: i32 = match guess.trim().parse() {
      Ok(num) => num,
      Err(_) => continue,
    };

    let guess = Guess::new(guess);
    // ...
  }
}

• getter：返回字段数据
  • 字段是私有的：外部无法直接对字段赋值