用 golang 开发文件处理时，会涉及到文件的读写，开始使用 golang 中的 io 包，后来发现 golang 中提供了一个 bufio 的包，使用这个 bufio 可以大幅提高文件读写的效率，文件读写为什么 bufio 要比 io 的读写更快速呢？
**bufio 包介绍 **
bufio 包实现了有缓冲的 I/O。它包装一个 io.Reader 或 io.Writer 接口对象，创建另一个也实现了该接口，且同时还提供了缓冲和一些文本 I/O 的帮助函数的对象。
以上为官方包的介绍，在其中我们能了解到的信息如下：
bufio 是通过缓冲来提高效率
简单的说就是，把文件读取进缓冲（内存）之后再读取的时候就可以避免文件系统的 io 从而提高速度。同理，在进行写操作时，先把文件写入缓冲（内存），然后由缓冲写入文件系统。看完以上解释有人可能会表示困惑了，直接把 内容-> 文件 和 内容-> 缓冲-> 文件相比， 缓冲区好像没有起到作用嘛。其实缓冲区的设计是为了存储多次的写入，最后一口气把缓冲区内容写入文件。下面会详细解释
bufio 封装了 io.Reader 或 io.Writer 接口对象，并创建另一个也实现了该接口的对象
io.Reader 或 io.Writer 接口实现 read() 和 write() 方法，对于实现这个接口的对象都是可以使用这两个方法的
bufio 包实现原理
bufio 源码分析
Reader 对象
bufio.Reader 是 bufio 中对 io.Reader 的封装
// Reader implements buffering for an io.Reader object.
type Reader struct {
buf []byte
rd io.Reader // reader provided by the client
r, w int // buf read and write positions
err error
lastByte int
lastRuneSize int
}
bufio.Read(p []byte) 相当于读取大小 len(p)的内容，思路如下：
- 当缓存区有内容的时，将缓存区内容全部填入 p 并清空缓存区
- 当缓存区没有内容的时候且 len(p)>len(buf),即要读取的内容比缓存区还要大，直接去文件读取即可
- 当缓存区没有内容的时候且 len(p)= len(b.buf) {
// Large read, empty buffer.
// Read directly into p to avoid copy.
n, b.err = b.rd.Read(p)
if n < 0 {
panic(errNegativeRead)
}
if n > 0 {
b.lastByte = int(p[n-1])
b.lastRuneSize = -1
}
return n, b.readErr()
}
// One read.
// Do not use b.fill, which will loop.
b.r = 0
b.w = 0
n, b.err = b.rd.Read(b.buf)
if n < 0 {
panic(errNegativeRead)
}
if n == 0 {
return 0, b.readErr()
}
b.w += n
}
// copy as much as we can
n = copy(p, b.buf[b.r:b.w])
b.r += n
b.lastByte = int(b.buf[b.r-1])
b.lastRuneSize = -1
return n, nil
}
说明：
reader 内部通过维护一个 r, w 即读入和写入的位置索引来判断是否缓存区内容被全部读出
Writer 对象
bufio.Writer 是 bufio 中对 io.Writer 的封装
// Writer implements buffering for an io.Writer object.
type Writer struct {
err error
buf []byte
n int
wr io.Writer
}
bufio.Write(p []byte) 的思路如下
1. 判断 buf 中可用容量是否可以放下 p
2. 如果能放下，直接把 p 拼接到 buf 后面，即把内容放到缓冲区
3. 如果缓冲区的可用容量不足以放下，且此时缓冲区是空的，直接把 p 写入文件即可
4. 如果缓冲区的可用容量不足以放下，且此时缓冲区有内容，则用 p 把缓冲区填满，把缓冲区所有内容写入文件，并清空缓冲区
5. 判断 p 的剩余内容大小能否放到缓冲区，如果能放下（此时和步骤 1 情况一样）则把内容放到缓冲区
6. 如果 p 的剩余内容依旧大于缓冲区，（注意此时缓冲区是空的，情况和步骤 2 一样）则把 p 的剩余内容直接写入文件
以下是源码
// Write writes the contents of p into the buffer.
// It returns the number of bytes written.
// If nn < len(p), it also returns an error explaining
// why the write is short.
func (b *Writer) Write(p []byte) (nn int, err error) {
for len(p) > b.Available() && b.err == nil {
var n int
if b.Buffered() == 0 {
// Large write, empty buffer.
// Write directly from p to avoid copy.
n, b.err = b.wr.Write(p)
} else {
n = copy(b.buf[b.n:], p)
b.n += n
b.flush()
}
nn += n
p = p[n:]
}
if b.err != nil {
return nn, b.err
}
n := copy(b.buf[b.n:], p)
b.n += n
nn += n
return nn, nil
}
说明：
b.wr 存储的是一个 io.writer 对象，实现了 Write()的接口，所以可以使用 b.wr.Write(p) 将 p 的内容写入文件
b.flush() 会将缓存区内容写入文件，当所有写入完成后，因为缓存区会存储内容，所以需要手动 flush()到文件
b.Available() 为 buf 可用容量，等于 len(buf) - n
下图解释的是其中一种情况，即缓存区有内容，剩余 p 大于缓存区
