从 golang 中的缓冲读取器读取特定数量的字节

Question

我从 bufio 包中了解到 golang 中的特定功能。

func (b *Reader) Peek(n int) ([]byte, error)

Peek 返回接下来的 n 个字节不推进阅读器。字节 在下一次读取调用时停止有效。如果 Peek 返回小于 n 字节，它还返回一个错误，解释为什么读取很短。这 如果 n 大于 b 的缓冲区大小，则错误为 ErrBufferFull。

我需要能够从阅读器中读取特定数量的字节，这将推动阅读器。基本上，与上面的功能相同，但它使读者进步。有谁知道如何做到这一点？

Answer 1

如果您想从io.Reader 读取字节并进入io.Writer，那么您可以使用io.CopyN

CopyN 从 src 复制 n 个字节（或直到出错）到 dst。它返回复制的字节数和复制时遇到的最早错误。

返回时，写入 == n 当且仅当 err == nil。

written, err := io.CopyN(dst, src, n)
if err != nil {
    // We didn't read the desired number of bytes
} else {
   // We can proceed successfully
}

Answer 2

TLDR：

my42bytes, err := ioutil.ReadAll(io.LimitReader(myReader, 42))

完整答案：

@monicuta 提到了io.ReadFull，效果很好。这里我提供另一种方法。它通过将ioutil.ReadAll 和io.LimitReader 链接在一起来工作。让我们先阅读文档：

$ go doc ioutil.ReadAll
func ReadAll(r io.Reader) ([]byte, error)
     ReadAll reads from r until an error or EOF and returns the data it read. A
     successful call returns err == nil, not err == EOF. Because ReadAll is
     defined to read from src until EOF, it does not treat an EOF from Read as an
     error to be reported. 

$ go doc io.LimitReader
func LimitReader(r Reader, n int64) Reader
     LimitReader returns a Reader that reads from r but stops with EOF after n
     bytes. The underlying implementation is a *LimitedReader.

所以如果你想从myReader 获取 42 个字节，你可以这样做

import (
        "io"
        "io/ioutil"
)

func main() {
        // myReader := ...
        my42bytes, err := ioutil.ReadAll(io.LimitReader(myReader, 42))
        if err != nil {
                panic(err)
        }
        //...
}

这是io.ReadFull的等效代码

$ go doc io.ReadFull
func ReadFull(r Reader, buf []byte) (n int, err error)
    ReadFull reads exactly len(buf) bytes from r into buf. It returns the number
    of bytes copied and an error if fewer bytes were read. The error is EOF only
    if no bytes were read. If an EOF happens after reading some but not all the
    bytes, ReadFull returns ErrUnexpectedEOF. On return, n == len(buf) if and
    only if err == nil. If r returns an error having read at least len(buf)
    bytes, the error is dropped.

import (
        "io"
)

func main() {
        // myReader := ...
        buf := make([]byte, 42)
        _, err := io.ReadFull(myReader, buf)
        if err != nil {
                panic(err)
        }
        //...
}

与io.ReadFull相比，一个优点是您不需要手动创建buf，其中len(buf)是您要读取的字节数，然后在您传递buf作为参数时阅读

相反，您只需告诉io.LimitReader 您最多需要来自myReader 的42 个字节，然后调用ioutil.ReadAll 将它们全部读取，并将结果作为字节片返回。如果成功，则保证返回的切片长度为 42。

Answer 3

为此，您只需创建一个字节切片并将read 数据放入该切片中

n := 512
buff := make([]byte, n)
fs.Read(buff)  // fs is your reader. Can be like this fs, _ := os.Open('file')

---

func (b *Reader) Read(p []byte) (n int, err error)

Read 将数据读入 p。它返回读入 p 的字节数。 这些字节最多取自底层 Reader 上的一个 Read， 因此 n 可能小于 len(p)

Answer 4

我更喜欢 Read() 尤其是当你要读取任何类型的文件时，它在以块的形式发送数据时也很有用，下面是一个例子来展示它是如何使用的

fs, err := os.Open("fileName"); 

if err != nil{
    fmt.Println("error reading file")
    return
}

defer fs.Close()

reader := bufio.NewReader(fs)

buf := make([]byte, 1024)

for{
    v, _ := reader.Read(buf) //ReadString and ReadLine() also applicable or alternative

    if v == 0{
        return
    }
    //in case it is a string file, you could check its content here...
    fmt.Print(string(buf))
}

Answer 5

注意bufio.Read 方法最多调用底层io.Read 一次，这意味着它可以返回n < len(p)，而不会到达EOF。如果您想准确读取len(p) 字节或因错误而失败，您可以像这样使用io.ReadFull：

n, err := io.ReadFull(reader, p)

即使阅读器被缓冲，这也有效。

Answer 6

func (b *Reader) Read(p []byte) (n int, err error)

http://golang.org/pkg/bufio/#Reader.Read

读取的字节数将被限制为len(p)

Answer 7

将一个 n 字节大小的缓冲区传递给阅读器。