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(buf),即要读取的内容比缓存区小，缓存区从文件读取内容充满缓存区，并将p填满（此时缓存区有剩余内容）
以后再次读取时缓存区有内容，将缓存区内容全部填入p并清空缓存区（此时和情况1一样）
以下是源码
// Read reads data into p.
// It returns the number of bytes read into p.
// The bytes are taken from at most one Read on the underlying Reader,
// hence n may be less than len(p).
// At EOF, the count will be zero and err will be io.EOF.
func (b *Reader) Read(p []byte) (n int, err error) {
n = len(p)
if n == 0 {
return 0, b.readErr()
}
if b.r == b.w {
if b.err != nil {
return 0, b.readErr()
}
if 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) 的思路如下
判断buf中可用容量是否可以放下 p
如果能放下，直接把p拼接到buf后面，即把内容放到缓冲区
如果缓冲区的可用容量不足以放下，且此时缓冲区是空的，直接把p写入文件即可
如果缓冲区的可用容量不足以放下，且此时缓冲区有内容，则用p把缓冲区填满，把缓冲区所有内容写入文件，并清空缓冲区
判断p的剩余内容大小能否放到缓冲区，如果能放下（此时和步骤1情况一样）则把内容放到缓冲区
如果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大于缓存区
golang的 bufio 包里面定以的 SplitFunc 是一个比较重要也比较难以理解的东西，本文希望通过结合简单的实例介绍 SplitFunc 的工作原理以及如何实现一个自己的 SplitFunc 。
在 bufio 包里面定义了一些常用的工具比如 Scanner ,你可能需要读取用户在标准输入里面输入的一些东西，比如我们做一个 复读机 ，读取用户的每一行输入，然后打印出来：
这个程序很简单， os.Stdin 实现了 io.Reader 接口，我们从这个reader创建了一个 scanner ,设置分割函数为 bufio.ScanLines ，然后 for 循环，每次读到一行数据就将文本内容打印出来。麻雀虽小五脏俱全，这个小程序虽然简单，却引出了我们今天要介绍的对象: bufio.SplitFunc ,它的定义是这个样子的：
golang官方文档的描述是这个样子的：
英文！参数这么多！返回值这么多！好烦！不知道各位读者遇到这种文档会不会有这种感觉...正式由于这种情况，我才决定写一篇文章介绍一下 SplitFunc 的具体工作原理，用一种通俗的方式结合具体实例加以说明，希望对读者有所帮助。
好了，废话少说，开始正题吧！
Scanner 是有缓存的，意思是 Scanner 底层维护了一个 Slice 用来保存已经从 Reader 中读取的数据， Scanner 会调用我们设置 SplitFunc ，将缓冲区内容(data)和是否已经输入完了(atEOF)以参数的形式传递给 SplitFunc ，而 SplitFunc 的职责就是根据上述的两个参数返回下一次 Scan 需要前进几个字节(advance)，分割出来的数据(token)，以及错误(err)。
这是一个通信双向的过程， Scanner 告诉我们的 SplitFunc 已经扫描到的数据和是否到结尾了，我们的 SplitFunc 则根据这些信息将分割的结果返回和下次扫描需要前进的位置返回给 Scanner 。用一个例子来说明：
输出
这里我们把缓冲区的初始大小设置为了2，不够的时候会扩展为原来的2倍，最大为 bufio.MaxScanTokenSize ,这样一开始扫描2个字节，我们的缓冲区就满了，reader的内容还没有读取到EOF，然后split函数执行，输出:
紧接着函数返回 0, nil, nil 这个返回值告诉Scanner数据不够，下次读取的位置前进0位，需要继续从reader里面读取,此时因为缓冲区满了，所以容量扩展为 2 * 2 = 4 ，reader的内容还没有读取到EOF，输出
重复上述步骤，一直到最后全部内容读取完了，EOF此时变成了true
看了上面的过程是不是对SplitFunc的工作原来有了一点理解了呢？再回头看一下golang的官方文档有没有觉得稍微理解了一点?下面是 bufio.ScanLines 的实现，读者可以自己研究一下该函数是如何工作的
In-depth introduction to bufio.Scanner in Golang
