Fade away

Appearance

Struct std::io::LineWriter ​

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

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

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

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

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

示例

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

rust
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> ​

new ​

创建一个新的 LineWriter。

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

示例

rust
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(())
}

with_capacity ​

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

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

示例

rust
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(())
}

get_ref ​

获取对底层 writer 的引用。

rust
pub fn get_ref(&self) -> &W

示例

rust
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(())
}

get_mut ​

获取底层 writer 的可变引用。

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

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

示例

rust
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(())
}

into_inner ​

对 LineWriter 解包，返回底层 writer。

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

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

Errors

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

rust
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> ​

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

fmt ​

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

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

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

write ​

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

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

flush ​

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

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

write_vectored ​

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

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

is_write_vectored ​

nightly-only

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

rust
fn is_write_vectored(&self) -> bool

write_all ​

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

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

write_all_vectored ​

nightly-only

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

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

write_fmt ​

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

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

by_ref ​

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

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

Auto Trait Implementations ​

impl<W> RefUnwindSafe for LineWriter<W> ​

rust
impl<W> RefUnwindSafe for LineWriter<W>
where
  W: RefUnwindSafe,

impl<W> Send for LineWriter<W> ​

rust
impl<W> Send for LineWriter<W>
where
  W: Send,

impl<W> Sync for LineWriter<W> ​

rust
impl<W> Sync for LineWriter<W>
where
  W: Sync,

impl<W> Unpin for LineWriter<W> ​

rust
impl<W> Unpin for LineWriter<W>
where
  W: Unpin,

impl<W> UnwindSafe for LineWriter<W> ​

rust
impl<W> UnwindSafe for LineWriter<W>
where
  W: UnwindSafe,

Blanket Implementations ​

impl<T> Any for T ​

rust
impl<T> Any for T
where
  T: 'static + ?Sized,

impl<T> Borrow<T> for T ​

rust
impl<T> Borrow<T> for T
where
  T: ?Sized,

impl<T> BorrowMut<T> for T ​

rust
impl<T> BorrowMut<T> for T
where
  T: ?Sized,

impl<T> From<T> for T ​

impl<T, U> Into<U> for T ​

rust
impl<T, U> Into<U> for T
where
  U: From<T>,

impl<T, U> TryFrom<U> for T ​

rust
impl<T, U> TryFrom<U> for T
where
  U: Into<T>,

impl<T, U> TryInto<U> for T ​

rust
impl<T, U> TryInto<U> for T
where
  U: TryFrom<T>,

MIT Licensed

Copyright © 2024-present xarzhi