Module std::io1.0.0[−][src]

Expand description

核心 I/O 功能的 Traits，帮助程序和类型定义。

std::io 模块包含许多在执行输入和输出时需要的常见操作。该模块中最核心的部分是 Read 和 Write traits，它们提供用于读取和写入输入和输出的最通用接口。

读和写

因为它们是 traits，所以 Read 和 Write 由许多其他类型实现，您也可以为您的类型实现它们。这样，您将在此模块的整个文档中看到几种不同类型的 I/O: File，TcpStream，有时甚至是 Vec<T>。例如，Read 添加了 read 方法，我们可以在 File 上使用该方法：

use std::io;
use std::io::prelude::*;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut f = File::open("foo.txt")?;
    let mut buffer = [0; 10];

    // 最多读取 10 个字节
    let n = f.read(&mut buffer)?;

    println!("The bytes: {:?}", &buffer[..n]);
    Ok(())
}

Run

Read 和 Write 非常重要，两个 traits 的实现者有一个昵称: readers 和 writers。因此，有时您会看到 reader 而不是 实现 [Read] trait 的类型。容易得多！

Seek 和 BufRead

除此之外，还提供了两个重要的 traits: Seek 和 BufRead。两者都建立在 reader 的顶部，以控制读取的方式。 Seek 可让您控制下一个字节的来源：

use std::io;
use std::io::prelude::*;
use std::io::SeekFrom;
use std::fs::File;

fn main() -> io::Result<()> {
    let mut f = File::open("foo.txt")?;
    let mut buffer = [0; 10];

    // 跳到文件的最后 10 个字节
    f.seek(SeekFrom::End(-10))?;

    // 最多读取 10 个字节
    let n = f.read(&mut buffer)?;

    println!("The bytes: {:?}", &buffer[..n]);
    Ok(())
}

Run

BufRead 使用内部缓冲区来提供许多其他读取方式，但为了展示它，我们需要一般地讨论缓冲区。继续阅读！

BufReader 和 BufWriter

基于字节的接口笨拙且效率低下，因为我们需要对操作系统进行近乎恒定的调用。为了解决这个问题，std::io 带有两个结构体 BufReader 和 BufWriter，它们包装了 readers 和 writers。包装器使用缓冲区，从而减少了调用次数，并提供了更好的方法来访问所需的内容。

例如，BufReader 与 BufRead trait 一起为任何 reader 添加额外的方法：

use std::io;
use std::io::prelude::*;
use std::io::BufReader;
use std::fs::File;

fn main() -> io::Result<()> {
    let f = File::open("foo.txt")?;
    let mut reader = BufReader::new(f);
    let mut buffer = String::new();

    // 将一行读入缓冲区
    reader.read_line(&mut buffer)?;

    println!("{}", buffer);
    Ok(())
}

Run

BufWriter 没有添加任何新的写入方式；它只是缓冲每个调用到 write：

use std::io;
use std::io::prelude::*;
use std::io::BufWriter;
use std::fs::File;

fn main() -> io::Result<()> {
    let f = File::create("foo.txt")?;
    {
        let mut writer = BufWriter::new(f);

        // 向缓冲区写入一个字节
        writer.write(&[42])?;

    } // writer 离开作用域后，将刷新缓冲区

    Ok(())
}

Run

标准输入输出

输入的一个非常常见的来源是标准输入：

use std::io;

fn main() -> io::Result<()> {
    let mut input = String::new();

    io::stdin().read_line(&mut input)?;

    println!("You typed: {}", input.trim());
    Ok(())
}

Run

请注意，不能在不返回 Result<T, E> 的函数中使用 ? operator。相反，您可以在返回值上调用 .unwrap() 或 match 来捕获任何可能的错误：

use std::io;

let mut input = String::new();

io::stdin().read_line(&mut input).unwrap();

Run

标准输出是一个非常常见的输出源：

use std::io;
use std::io::prelude::*;

fn main() -> io::Result<()> {
    io::stdout().write(&[42])?;
    Ok(())
}

Run

当然，直接使用 io::stdout 比使用 println! 少见。

迭代器类型

std::io 提供的大量结构用于在 I/O 上进行迭代的各种方式。例如，Lines 用于拆分多行：

use std::io;
use std::io::prelude::*;
use std::io::BufReader;
use std::fs::File;

fn main() -> io::Result<()> {
    let f = File::open("foo.txt")?;
    let reader = BufReader::new(f);

    for line in reader.lines() {
        println!("{}", line?);
    }
    Ok(())
}

Run

Functions

有许多函数提供对各种特性的访问。例如，我们可以使用以下三个函数将所有内容从标准输入复制到标准输出：

use std::io;

fn main() -> io::Result<()> {
    io::copy(&mut io::stdin(), &mut io::stdout())?;
    Ok(())
}

Run

io::Result

最后但并非最不重要的是 io::Result。此类型用作许多 std::io 函数的返回类型，它们可能导致错误，也可以从您自己的函数中返回。该模块中的许多示例都使用 ? operator：

use std::io;

fn read_input() -> io::Result<()> {
    let mut input = String::new();

    io::stdin().read_line(&mut input)?;

    println!("You typed: {}", input.trim());

    Ok(())
}