Struct std::io::Error

pub struct Error { /* fields omitted */ }

Read，Write，Seek 和关联的 traits 的 I/O 操作的错误类型。

错误主要来自底层操作系统，但可以使用精心制作的错误消息和特定的 ErrorKind 值来创建 Error 的自定义实例。

Implementations

impl Error

pub fn new<E>(kind: ErrorKind, error: E) -> Error where
    E: Into<Box<dyn Error + Send + Sync>>, 

根据已知的错误以及任意的错误有效载荷创建新的 I/O 错误。

此函数通常用于创建 I/O 错误，这些错误并非源于操作系统本身。 error 参数是将包含在此 Error 中的任意有效载荷。

如果不需要额外的有效载荷，请使用来自 ErrorKind 的 From 转换。

Examples

use std::io::{Error, ErrorKind};

// 可以从字符串创建错误
let custom_error = Error::new(ErrorKind::Other, "oh no!");

// 错误也可以从其他错误中创建
let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);

// 在没有有效载荷的情况下创建错误
let eof_error = Error::from(ErrorKind::UnexpectedEof);

pub fn other<E>(error: E) -> Error where
    E: Into<Box<dyn Error + Send + Sync>>, 

🔬 This is a nightly-only experimental API. (io_error_other #91946)

从任意错误有效载荷创建新的 I/O 错误。

此函数通常用于创建 I/O 错误，这些错误并非源于操作系统本身。 它是 Error::new 与 ErrorKind::Other 的快捷方式。

Examples

#![feature(io_error_other)]

use std::io::Error;

// 可以从字符串创建错误
let custom_error = Error::other("oh no!");

// 错误也可以从其他错误中创建
let custom_error2 = Error::other(custom_error);

pub fn last_os_error() -> Error

返回代表最近发生的操作系统错误的错误。

该函数读取目标平台的 errno 值 (例如， Windows 上的 GetLastError) 并将为错误代码返回相应的 Error 实例。

这应该在调用到平台函数之后立即调用，否则错误值的状态是不确定的。 特别是，其他标准库函数可能会调用平台函数，即使它们成功也可能 (或可能不会) 重置错误值。

Examples

use std::io::Error;

let os_error = Error::last_os_error();
println!("last OS error: {:?}", os_error);

pub fn from_raw_os_error(code: i32) -> Error

根据特定的操作系统错误代码创建 Error 的新实例。

Examples

在 Linux 上：

use std::io;

let error = io::Error::from_raw_os_error(22);
assert_eq!(error.kind(), io::ErrorKind::InvalidInput);

在 Windows 上：

use std::io;

let error = io::Error::from_raw_os_error(10022);
assert_eq!(error.kind(), io::ErrorKind::InvalidInput);

pub fn raw_os_error(&self) -> Option<i32>

返回此错误表示的操作系统错误 (如果有)。

如果此 Error 是通过 last_os_error 或 from_raw_os_error 构造的，则此函数将返回 Some，否则它将返回 None。

Examples

use std::io::{Error, ErrorKind};

fn print_os_error(err: &Error) {
    if let Some(raw_os_err) = err.raw_os_error() {
        println!("raw OS error: {:?}", raw_os_err);
    } else {
        println!("Not an OS error");
    }
}

fn main() {
    // 将打印 "raw OS error: ..."。
    print_os_error(&Error::last_os_error());
    // 将打印 "Not an OS error"。
    print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
}

pub fn get_ref(&self) -> Option<&(dyn Error + Send + Sync + 'static)>

返回对此错误包装的内部错误 (如果有) 的引用。

如果此 Error 是通过 new 构造的，则此函数将返回 Some，否则它将返回 None。

Examples

use std::io::{Error, ErrorKind};

fn print_error(err: &Error) {
    if let Some(inner_err) = err.get_ref() {
        println!("Inner error: {:?}", inner_err);
    } else {
        println!("No inner error");
    }
}

fn main() {
    // 将打印 "No inner error"。
    print_error(&Error::last_os_error());
    // 将打印 "Inner error: ..."。
    print_error(&Error::new(ErrorKind::Other, "oh no!"));
}

pub fn get_mut(&mut self) -> Option<&mut (dyn Error + Send + Sync + 'static)>

返回对此错误包装的内部错误的可变引用 (如果有)。

如果此 Error 是通过 new 构造的，则此函数将返回 Some，否则它将返回 None。

Examples

use std::io::{Error, ErrorKind};
use std::{error, fmt};
use std::fmt::Display;

#[derive(Debug)]
struct MyError {
    v: String,
}

impl MyError {
    fn new() -> MyError {
        MyError {
            v: "oh no!".to_string()
        }
    }

    fn change_message(&mut self, new_message: &str) {
        self.v = new_message.to_string();
    }
}

impl error::Error for MyError {}

impl Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "MyError: {}", &self.v)
    }
}

fn change_error(mut err: Error) -> Error {
    if let Some(inner_err) = err.get_mut() {
        inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");
    }
    err
}

fn print_error(err: &Error) {
    if let Some(inner_err) = err.get_ref() {
        println!("Inner error: {}", inner_err);
    } else {
        println!("No inner error");
    }
}

fn main() {
    // 将打印 "No inner error"。
    print_error(&change_error(Error::last_os_error()));
    // 将打印 "Inner error: ..."。
    print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
}

pub fn into_inner(self) -> Option<Box<dyn Error + Send + Sync>>

消耗 Error，并返回其内部错误 (如果有)。

如果此 Error 是通过 new 构造的，则此函数将返回 Some，否则它将返回 None。

Examples

use std::io::{Error, ErrorKind};

fn print_error(err: Error) {
    if let Some(inner_err) = err.into_inner() {
        println!("Inner error: {}", inner_err);
    } else {
        println!("No inner error");
    }
}

fn main() {
    // 将打印 "No inner error"。
    print_error(Error::last_os_error());
    // 将打印 "Inner error: ..."。
    print_error(Error::new(ErrorKind::Other, "oh no!"));
}

pub fn kind(&self) -> ErrorKind

返回与此错误对应的 ErrorKind。

Examples

use std::io::{Error, ErrorKind};

fn print_error(err: Error) {
    println!("{:?}", err.kind());
}

fn main() {
    // 将打印 "Uncategorized"。
    print_error(Error::last_os_error());
    // 将打印 "AddrInUse"。
    print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
}

Trait Implementations

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。

impl Display for Error

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。

impl Error for Error

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn source(&self) -> Option<&(dyn Error + 'static)>

此错误的下级来源 (如果有)。

fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace #53487)

返回发生错误的栈回溯 (如果有)。

impl From<ErrorKind> for Error

旨在用于未暴露给用户的错误，因为分配到堆上 (通过 Error::new 进行常规构建) 的代价太高了。

fn from(kind: ErrorKind) -> Error

将 ErrorKind 转换为 Error。

此转换使用错误类型的简单表示来分配新错误。

Examples

use std::io::{Error, ErrorKind};

let not_found = ErrorKind::NotFound;
let error = Error::from(not_found);
assert_eq!("entity not found", format!("{}", error));

impl<W> From<IntoInnerError<W>> for Error

fn from(iie: IntoInnerError<W>) -> Error

执行转换。

impl From<NulError> for Error

fn from(_: NulError) -> Error

将 NulError 转换为 io::Error。