Struct std::io::LineWriter

pub struct LineWriter<W: Write> { /* private fields */ }

包装一个 writer 并缓冲输出到它的内容，每当检测到换行符 (0x0a，‘\n’`) 时刷新一次。

BufWriter 结构体包装 writer 并缓冲其输出。 但是，仅当它离开作用域或内部缓冲区已满时，才进行此批量写入。 有时，您宁愿在完成时写每一行，而不是一次写整个缓冲区。 输入 LineWriter。 它正是这样做的。

像 BufWriter 一样，当 LineWriter 离开作用域或其内部缓冲区已满时，也会刷新 LineWriter 的缓冲区。

如果丢弃 LineWriter 时缓冲区中仍然有部分行，它将刷新这些内容。

Examples

我们可以使用 LineWriter 一次写入一行，从而大大减少了实际写入文件的次数。

use std::fs::{self, File};
use std::io::prelude::*;
use std::io::LineWriter;

fn main() -> std::io::Result<()> {
    let road_not_taken = b"I shall be telling this with a sigh
Somewhere ages and ages hence:
Two roads diverged in a wood, and I -
I took the one less traveled by,
And that has made all the difference.";

    let file = File::create("poem.txt")?;
    let mut file = LineWriter::new(file);

    file.write_all(b"I shall be telling this with a sigh")?;

    // 在遇到换行符 (或内部缓冲区已满) 之前，不会写入任何字节。
    assert_eq!(fs::read_to_string("poem.txt")?, "");
    file.write_all(b"\n")?;
    assert_eq!(
        fs::read_to_string("poem.txt")?,
        "I shall be telling this with a sigh\n",
    );

    // 写下这首诗的其余部分。
    file.write_all(b"Somewhere ages and ages hence:
Two roads diverged in a wood, and I -
I took the one less traveled by,
And that has made all the difference.")?;

    // 这首诗的最后一行不是以换行符结尾的，所以我们必须刷新或丢弃 `LineWriter` 来完成写作。
    file.flush()?;

    // 确认整首诗都写好了。
    assert_eq!(fs::read("poem.txt")?, &road_not_taken[..]);
    Ok(())
}

Implementations

impl<W: Write> LineWriter<W>

pub fn new(inner: W) -> LineWriter<W>

创建一个新的 LineWriter。

Examples

use std::fs::File;
use std::io::LineWriter;

fn main() -> std::io::Result<()> {
    let file = File::create("poem.txt")?;
    let file = LineWriter::new(file);
    Ok(())
}

pub fn with_capacity(capacity: usize, inner: W) -> LineWriter<W>

为内部缓冲区创建至少具有指定容量的新 LineWriter。

Examples

use std::fs::File;
use std::io::LineWriter;

fn main() -> std::io::Result<()> {
    let file = File::create("poem.txt")?;
    let file = LineWriter::with_capacity(100, file);
    Ok(())
}

pub fn get_ref(&self) -> &W

获取对底层 writer 的引用。

Examples

use std::fs::File;
use std::io::LineWriter;

fn main() -> std::io::Result<()> {
    let file = File::create("poem.txt")?;
    let file = LineWriter::new(file);

    let reference = file.get_ref();
    Ok(())
}

pub fn get_mut(&mut self) -> &mut W

获取底层 writer 的可变引用。

在返回的变量引用上调用方法时必须小心，因为额外的写操作可能会破坏输出流。

Examples

use std::fs::File;
use std::io::LineWriter;

fn main() -> std::io::Result<()> {
    let file = File::create("poem.txt")?;
    let mut file = LineWriter::new(file);

    // 我们可以像文件一样使用引用
    let reference = file.get_mut();
    Ok(())
}

pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>>

对 LineWriter 解包，返回底层 writer。

返回 writer 之前，将内部缓冲区写出。

Errors

如果刷新缓冲区时发生错误，将返回 Err。

Examples

use std::fs::File;
use std::io::LineWriter;

fn main() -> std::io::Result<()> {
    let file = File::create("poem.txt")?;

    let writer: LineWriter<File> = LineWriter::new(file);

    let file: File = writer.into_inner()?;
    Ok(())
}

Trait Implementations

impl<W> Debug for LineWriter<W>where W: Debug + Write,

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

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

impl<W: Write> Write for LineWriter<W>

fn write(&mut self, buf: &[u8]) -> Result<usize>

在此 writer 中写入一个缓冲区，返回写入的字节数。

fn flush(&mut self) -> Result<()>

刷新此输出流，确保所有中间缓冲的内容均到达其目的地。

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>

类似于 write，不同之处在于它是从缓冲区切片中写入数据的。

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector #69941)

确定此 Writer 是否具有有效的 write_vectored 实现。

fn write_all(&mut self, buf: &[u8]) -> Result<()>

尝试将整个缓冲区写入此 writer。

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<()>

🔬This is a nightly-only experimental API. (write_all_vectored #70436)

尝试将多个缓冲区写入此 writer。

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

将格式化的字符串写入此 writer，返回遇到的任何错误。

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

为这个 Write 实例创建一个 “by reference” 适配器。