Struct std::io::Error

pub struct Error { /* private fields */ }

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

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

Implementations

impl Error

pub fn new<E>(kind: ErrorKind, error: E) -> Errorwhere 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) -> Errorwhere 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: RawOsError) -> 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<RawOsError>

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

如果此 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 downcast<E>(self) -> Result<Box<E>, Self>where E: Error + Send + Sync + 'static,

🔬This is a nightly-only experimental API. (io_error_downcast #99262)

尝试将内部错误降级为 E (如果有)。

如果这个 Error 是通过 new 构建的，那么这个函数将尝试对其执行降级，否则它将返回 Err。

降级成功返回 Ok，否则返回 Err。

Examples

#![feature(io_error_downcast)]

use std::fmt;
use std::io;
use std::error::Error;

#[derive(Debug)]
enum E {
    Io(io::Error),
    SomeOtherVariant,
}

impl fmt::Display for E {
   // ...
}
impl Error for E {}

impl From<io::Error> for E {
    fn from(err: io::Error) -> E {
        err.downcast::<E>()
            .map(|b| *b)
            .unwrap_or_else(E::Io)
    }
}

pub fn kind(&self) -> ErrorKind

返回与此错误对应的 ErrorKind。

这可能是由 Rust 代码构造自定义 io::Error 设置的值，或者如果此 io::Error 来自操作系统，它将是从系统错误编码推断的值。

有关详细信息，请参见 last_os_error。

Examples

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

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

fn main() {
    // 由于没有发生 (visibly) 错误，这可能会打印任何内容!
    // 它可能会为未识别的 (非) 错误打印一个占位符。
    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 provide<'a>(&'a self, demand: &mut Demand<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access #99301)

提供对用于错误报告的上下文的基于类型的访问。

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

将 alloc::ffi::NulError 转换为 Error。