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大於緩存區