原本只想用用bufio，但是网上文章没有一个写清楚bufio到底怎么用，每个方法具体干了什么，搞不明白原理就不敢乱用，还好有源码，自己来分析最清楚。
Reader分析
func NewReaderSize(rd io.Reader, size int) *Reader {
// Is it already a Reader?
b, ok := rd.(*Reader)
if ok && len(b.buf) >= size {
return b
}
if size < minReadBufferSize { //minReadBufferSize==16
size = minReadBufferSize
}
r := new(Reader)
r.reset(make([]byte, size), rd)
return r
}
// NewReader returns a new Reader whose buffer has the default size.
func NewReader(rd io.Reader) *Reader {
return NewReaderSize(rd, defaultBufSize)
}
一开始传入io.Reader创建bufio.Reader，默认defaultBufSize为4096字节也就是4K字节。
// fill reads a new chunk into the buffer.
func (b *Reader) fill() {
// Slide existing data to beginning.
if b.r > 0 { //把buf剩余可读的数据复制到最前
copy(b.buf, b.buf[b.r:b.w])
b.w -= b.r
b.r = 0
}
if b.w >= len(b.buf) {//缓存已经溢出了
panic("bufio: tried to fill full buffer")
}
//maxConsecutiveEmptyReads == 100
// Read new data: try a limited number of times.
for i := maxConsecutiveEmptyReads; i > 0; i-- {
n, err := b.rd.Read(b.buf[b.w:]) //从io中读取数据写入缓存
if n < 0 {
panic(errNegativeRead)
}
b.w += n //更新写入缓存的长度
if err != nil {
b.err = err
return
}
if n > 0 {
return
}
// n== 0时会循环尝试从io中读取，最多100次
}
b.err = io.ErrNoProgress //读了100次，n都为0
}
fill()把剩余未读长度的数据复制到缓存头部并且r重置为0，相当于把未读数据移动到头部。同时尽量从io中读取数据写入缓存，有可能不能写满。
// ReadByte reads and returns a single byte.
// If no byte is available, returns an error.
func (b *Reader) ReadByte() (byte, error) {
b.lastRuneSize = -1
for b.r == b.w { //缓存中无数据可读
if b.err != nil {
return 0, b.readErr()
}
b.fill() // buffer is empty，从io中fill数据
}
c := b.buf[b.r]//此时肯定有数据了，取r位置的一个字节
b.r++ //r游标移动一个字节
b.lastByte = int(c)
return c, nil
}
ReadByte()从缓存中读取一个字节，如果缓存中没有数据则尝试从io中填充数据。最后返回读取到的一个字节的内容
// 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) { //p的空间大于等于缓存
// Large read, empty buffer.
// Read directly into p to avoid copy.
n, b.err = b.rd.Read(p)//直接从io中把数据读取到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.
// 无数据可读，表示buf中数据无用了则重置r和w的游标
b.r = 0
b.w = 0
n, b.err = b.rd.Read(b.buf)//从io中读取到缓存
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])//缓存中数据可读数据读取到p
b.r += n //读了多少
b.lastByte = int(b.buf[b.r-1])
b.lastRuneSize = -1
return n, nil
}
Read(p []byte)：
当缓存中没有可读数据时有两种情况：
情况1. 当p的空间大于等于缓存时，直接从io中把数据读取到p。
情况2. 当p的空间小于缓存时，重置缓存游标，尽量从io中读取数据到缓存 ，然后再从缓存中复制到p里。
当缓存中有可读数据时，直接从缓存中把可读数据复制到p中，此时不会去读取io。
p的空间有可能被填满，也有可能不满，返回的n说明读取了多少个字节。
// Peek returns the next n bytes without advancing the reader. The bytes stop
// being valid at the next read call. If Peek returns fewer than n bytes, it
// also returns an error explaining why the read is short. The error is
// ErrBufferFull if n is larger than b's buffer size.
func (b *Reader) Peek(n int) ([]byte, error) {
if n < 0 {
return nil, ErrNegativeCount
}
//剩余可读小于n而且小于缓存时从io里fill数据到缓存
for b.w-b.r < n && b.w-b.r < len(b.buf) && b.err == nil {
b.fill() // b.w-b.r < len(b.buf) => buffer is not full
}
//n比缓存大，返回可读的缓存切片，而且错误值为ErrBufferFull
if n > len(b.buf) {
return b.buf[b.r:b.w], ErrBufferFull
}
// 0 <= n <= len(b.buf)
var err error
if avail := b.w - b.r; avail < n {
// not enough data in buffer
//缓存的可读数据不够读，返回可以读的缓存切片及错误值ErrBufferFull
n = avail
err = b.readErr()
if err == nil {
err = ErrBufferFull
}
}
//如果缓存的可读数据足够就返回可读缓存切片和空错误
return b.buf[b.r : b.r+n], err
}
Peek(n int)：
先从io中填充缓存。
如果要读的n比缓存大返回错误值ErrBufferFull。
如果n小于等于缓存，且可读数据不够读返回ErrBufferFull或者io读错误。
如果有可够读的数据返回的错误为空。
不管怎样都会返回缓存可读取的切片但是没有移动读游标，修改返回的切片会影响缓存中的数据。
// Buffered returns the number of bytes that can be read from the current buffer.
func (b *Reader) Buffered() int { return b.w - b.r }//可读长度
// Discard skips the next n bytes, returning the number of bytes discarded.
//
// If Discard skips fewer than n bytes, it also returns an error.
// If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
// reading from the underlying io.Reader.
func (b *Reader) Discard(n int) (discarded int, err error) {
if n < 0 {
return 0, ErrNegativeCount
}
if n == 0 {
return
}
remain := n
for {
skip := b.Buffered()
if skip == 0 {//没可读先fill填充
b.fill()
skip = b.Buffered()
}
if skip > remain {
skip = remain
}
b.r += skip //读游标直接跳过skip个字节
remain -= skip
if remain == 0 {//成功跳过请求的字节长度
return n, nil
}
if b.err != nil {//出错了，返回剩下多少个字节没跳过和错误
return n - remain, b.readErr()
}
}
}
Discard(n int) ：
跳过n个字节不读取，一直循环到成功跳过或者出现错误。
Reader的其他方法我一般不用，所以也不分析了。
总结：
Peek返回错误不为空时，一种情况是你Peek的长度比缓存都大，那么数据永远不够，所以传入参数时要注意别比缓存大。
别一种情况是，从io里尝试读数据了但还是准备不够你需要的长度，比如网络tcp的数据一开始没有到达，等下一轮你再调用Peek时可能缓存就足够你读了。
其实就算有错误也会返回你可读取的切片。
如果错误为空，恭喜你，数据都准备好啦。
Peek不会移动读游标，如果直接使用Peek返回的切片可以配合Discard来跳过指定字节的数据不再读取也就是移动读游标。
Read尽量先从缓存中读取数据。当前缓存无数据可读时先从io中读取填充到缓存里，然后从缓存中复制。返回读取到的数据长度不一定，小于或者等于Read要求的长度。
想跳过n个字节不读取，使用Discard。
使用NewReader初始化时默认缓存为4096字节，在某些情况下可能太大浪费内存或者太小不够用，最好还是使用NewReaderSize根据情况自定义缓存大小。
Writer
有空再写