我知道来自于 bufio 包的特定函数在 Golang 中的作用。
func (b *Reader) Peek(n int) ([]byte, error)
Peek方法可以返回接下来的n个字节，但不会使读取器前进。这些字节在下一次读取调用时将变得无效。如果Peek返回少于n个字节，则它还会返回一个错误，解释为什么读取是不完整的。如果n大于b的缓冲区大小，则该错误是ErrBufferFull。
我需要从Reader中读取一定数量的字节并使读取器前进。基本上与上面的函数相同，但它会推进读取器。有人知道如何实现吗？
请注意，bufio.Read 方法最多调用一次底层的 io.Read，这意味着它可以返回 n < len(p) 而不会到达 EOF。如果您想要精确地读取 len(p) 字节或在出现错误时失败，可以像这样使用 io.ReadFull：
n, err := io.ReadFull(reader, p)
即使阅读器已缓冲，这也可以起作用。
func (b *Reader) Read(p []byte) (n int, err error)
http://golang.org/pkg/bufio/#Reader.Read
读取的字节数将受到 len(p) 的限制。
Read 直到获得预期数据。 并非所有读取器都是相同的。 此答案假定它们是相同的。 - Inanc Gumus简而言之：
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 相比，使用 io.LimitReader 的一个优点是您无需手动创建 buf，其中 len(buf) 是您想要读取的字节数，然后在 Read 时将 buf 作为参数传递。io.LimitReader 您最多从 myReader 中读取 42 字节，并调用 ioutil.ReadAll 读取它们所有，将结果作为字节切片返回。如果成功，返回的切片长度保证为 42。我更倾向于使用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))
}
Read()函数一定会读取所有的n字节。在某些边缘情况下，如果没有EOF，可能会导致浮点错误。最好分配一个确切大小的缓冲区buf := make([]byte, n)，然后使用io.ReadAtLeast(reader, buf, len(buf))函数。 - Denis如果你想从一个 io.Reader 中读取字节并写入到一个 io.Writer 中，那么你可以使用 io.CopyN
CopyN 从 src 复制 n 个字节（或直到出现错误）到 dst。它返回复制的字节数以及在复制过程中遇到的最早错误。
返回时，只有当 err == nil 时 written 才等于 n。
written, err := io.CopyN(dst, src, n)
if err != nil {
// We didn't read the desired number of bytes
} else {
// We can proceed successfully
}
要做到这一点，您只需要创建一个字节切片，并使用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中，并返回读入的字节数。 这些字节最多可以从底层Reader的一个Read操作中获取， 因此，实际读取的字节数可能小于len(p)
io.ReadAtLeast(reader, p, len(p))同时，在使用io.ReadFull时，你应该先定义p，并使其长度等于你想读取的字节数，但在使用io.ReadAtLeast时，p的长度可以随意设置，只要它比你想读取的字节数大或相等就行。 - sepehr