介绍
package bufio也是io的一部分，但在不同包中，因此独立一节。
其中包含bufio.go,scan.go两部分。
bufio
bufio的作用是为一个已有的Reader或者Writer提供缓冲，我们知道操作系统的io是资源瓶颈，应该尽可能少的调用io操作，所以把大批量的数据一起读取或写入是更好的选择。使用方法：
w := bufio.NewWriter(os.Stdout)
fmt.Fprint(w, "Hello, ")
fmt.Fprint(w, "world!")
w.Flush() // Don't forget to flush!
// Output: Hello, world!
源码中对Reader和Writer做了一个简单封装，bufio.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
}
除了包括原始的reader，还有一个[]byte结构，过程以Read方法为例：
// 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()
}
b.fill() // buffer is empty
if b.r == b.w {
return 0, b.readErr()
}
}
// 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的一次操作，
如果内部的buf小于提供的p，那么直接读取到p里，不经过buf。
如果buf更大，做一次fill操作：1.清理buf中的遗留数据到buf头部，2.读取内部reader到buf，并向后移动w，w+=n
最后做了一次copy操作，将buf的内容copy到p中。
再以Writer.Write为例：
// 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
}
解释:
n指buf中已经写了多少字节
b.Available()指buf中还剩多少字节可写，等于len(buf)-n
b.Buffered()就是n
来看过程：
首先如果n=0，那么直接把p写入到内部writer
如果buf中有东西，那么把p的内容先copy到buf中，并做一次flush（即buf写入writer）
只要buf中没有足够的空间（小于len(p))，都会持续的写入writer。
最后一点点尾巴，只能暂时留在buf里，等待下一次flush操作了。
在使用的场景中来看bufio.Writer的用途：
小buf，大量的写入数据：这样就类似于不加这个buf，只留一点点尾巴。
大buf，小数据写入：这样就有可能不写入，只是把数据先放到buf里。
Scanner
Scanner的作用是对一个Reader进行迭代，使用方式如下：
scanner := bufio.NewScanner(reader)
for scanner.Scan() {
fmt.Println(scanner.Text()) // Println will add back the final '\n'
}
默认按照一行一行进行读取，每次scan，scanner.Text()都会返回下一行的数据，直到EOF，Scan()返回false。
我们来看源码，主要是Scanner结构：
type Scanner struct {
r io.Reader // The reader provided by the client.
split SplitFunc // The function to split the tokens.
maxTokenSize int // Maximum size of a token; modified by tests.
token []byte // Last token returned by split.
buf []byte // Buffer used as argument to split.
start int // First non-processed byte in buf.
end int // End of data in buf.
err error // Sticky error.
empties int // Count of successive empty tokens.
scanCalled bool // Scan has been called; buffer is in use.
done bool // Scan has finished.
}
每次返回的『一行』（其实未必是一行，暂且这么叫）称为token，移动到下一个token称为一次advance，通过split函数做tokenize。其他都是一些比较明显的辅助字段。
这里主要是这个split函数，默认的bufio.NewScanner()代码如下：
func NewScanner(r io.Reader) *Scanner {
return &Scanner{
r: r,
split: ScanLines,
maxTokenSize: MaxScanTokenSize,
}
}
以分行函数作为split，同时看到MaxScanTokenSize = 64 * 1024,也就是说一行不能太长。否则会抛错，除非使用scanner.Buffer()方法自己提供缓冲区和最大容量。
除了默认的ScanLines，系统还提供了ScanRunes,ScanWords,ScanBytes三个split函数，用户也可以自定义split函数。
