Io 读取字节时，填充用户提供的缓冲区的惯用方法是什么？

返回实际读取的字节数，该字节数可以小于请求的缓冲区。在许多情况下，可以多次调用

read

，以完全填充缓冲区

我有这个代码，但看起来很笨拙：

use std::io::{self, Read};

fn read_complete<R>(mut rdr: R, buf: &mut [u8]) -> io::Result<()>
    where R: Read
{
    let mut total_read = 0;

    loop {
        let window = &mut buf[total_read..];
        let bytes_read = try!(rdr.read(window));

        // Completely filled the buffer
        if window.len() == bytes_read {
            return Ok(());
        }

        // Unable to read anything
        if bytes_read == 0 {
            return Err(io::Error::new(io::ErrorKind::Other, "Unable to read complete buffer"));
        }

        // Partial read, continue
        total_read += bytes_read;
    }
}

fn main() {}

使用std:：io:：{self，Read}；
fn read_complete（mut-rdr:R，buf:&mut[u8]）->io:：Result
R:Read在哪里
{
让mut total_read=0；
环路{
let window=&mut buf[total_read..]；
让bytes_read=try！（rdr.read（窗口））；
//完全填满了缓冲区
如果window.len（）==字节\u读取{
返回Ok（（））；
}
//什么都看不懂
如果字节_read==0{
返回Err（io:：Error:：new（io:：ErrorKind:：Other，“无法读取完整缓冲区”）；
}
//部分读取，继续
读取的总字节数+=读取的字节数；
}
}
fn main（）{}

标准库中是否有一个函数可以为我提取这项工作

此答案适用于1.6.0之前的版本

据我所知不是这样

查看，这里还定义了一个

read\u all

方法：

fn read_full<R: io::Read + ?Sized>(rdr: &mut R, buf: &mut [u8]) -> Result<()> {
    let mut nread = 0usize;
    while nread < buf.len() {
        match rdr.read(&mut buf[nread..]) {
            Ok(0) => return Err(Error::UnexpectedEOF),
            Ok(n) => nread += n,
            Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {},
            Err(e) => return Err(From::from(e))
        }
    }
    Ok(())
}

fn读取完整（rdr:&mut R，buf:&mut[u8]）->结果{
让mut nread=0使用；
而nread返回Err（Error:：UnexpectedEOF），
正常（n）=>nread+=n，
Err（ref e）如果e.kind（）==io:：ErrorKind:：Interrupted=>{}，
Err（e）=>返回Err（From:：From（e））
}
}
好（（））
}

请注意，这涉及中断的IO操作

还有一个，是几个月前提交的，进入了最终评论期，然后改变的足够多，它被带出了最终评论期，正在等待下一次的修改

事实证明，这出乎意料地复杂P

由于另一个答案中提到的在Rust 1.6.0中被接受、实现并可用，因此您可以使用以下方法：

或者，使用

？

运算符：

try!(r.read_exact(&mut buf))

r.read_exact(&mut buf)?