bufio
前言
最近操作文件，進行優化使用到了bufio。好像也不太了解這個，那么就梳理下，bufio的使用。
例子
我的場景：使用xml拼接了office2003的文檔。寫入到buffer，然后處理完了，轉存到文件里面。
type Buff struct {
Buffer *bytes.Buffer
Writer *bufio.Writer
}
// 初始化
func NewBuff() *Buff {
b := bytes.NewBuffer([]byte{})
return &Buff{
Buffer: b,
Writer: bufio.NewWriter(b),
}
}
func (b *Buff) WriteString(str string) error {
_, err := b.Writer.WriteString(str)
return err
}
func (b *Buff) SaveAS(name string) error {
file, err := os.OpenFile(name, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0666)
if err != nil {
return err
}
defer file.Close()
if err := b.Writer.Flush(); err != nil {
return nil
}
_, err = b.Buffer.WriteTo(file)
return err
}
func main() {
var b = NewBuff()
b.WriteString("haah")
}
bufio
Package bufio implements buffered I/O. It wraps an io.Reader or io.Writer object, creating another object (Reader or Writer) that also implements the interface but provides buffering and some help for textual I/O.
bufio包實現了有緩沖的I/O。它包裝一個io.Reader或io.Writer接口對象，創建另一個也實現了該接口，且同時還提供了緩沖和一些文本I/O的幫助函數的對象。
簡單的說就是bufio會把文件內容讀取到緩存中（內存），然后再取讀取需要的內容的時候，直接在緩存中讀取，避免文件的i/o操作。同樣，通過bufio寫入內容，也是先寫入到緩存中（內存），然后由緩存寫入到文件。避免多次小內容的寫入操作I/O。
源碼解析
Reader對象
bufio.Reader 是bufio中對io.Reader 的封裝
// Reader implements buffering for an io.Reader object.
type Reader struct {
buf []byte
rd io.Reader // 底層的io.Reader
r, w int // r:從buf中讀走的字節（偏移）；w:buf中填充內容的偏移；
// w - r 是buf中可被讀的長度（緩存數據的大小），也是Buffered()方法的返回值
err error
lastByte int // 最后一次讀到的字節（ReadByte/UnreadByte)
lastRuneSize int // 最后一次讀到的Rune的大小(ReadRune/UnreadRune)
}
bufio.Read(p []byte) 的思路如下：
1、當緩存區有內容的時，將緩存區內容全部填入p並清空緩存區
2、當緩存區沒有內容的時候且len(p)>len(buf),即要讀取的內容比緩存區還要大，直接去文件讀取即可
3、當緩存區沒有內容的時候且len(p)<len(buf),即要讀取的內容比緩存區小，緩存區從文件讀取內容充滿緩存區，並將p填滿（此時緩存區有剩余內容）
4、以后再次讀取時緩存區有內容，將緩存區內容全部填入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).
// To read exactly len(p) bytes, use io.ReadFull(b, 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 {
if b.Buffered() > 0 {
return 0, nil
}
return 0, b.readErr()
}
// r:從buf中讀走的字節（偏移）；w:buf中填充內容的偏移；
// w - r 是buf中可被讀的長度（緩存數據的大小），也是Buffered()方法的返回值
// b.r == b.w 表示，當前緩沖區里面沒有內容
if b.r == b.w {
if b.err != nil {
return 0, b.readErr()
}
// 如果p的大小大於等於緩沖區大小，則直接將數據讀入p，然后返回
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()
}
// buff容量大於p，直接將buff中填滿
// 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緩存區的內容到p中（填充滿p）
// 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
}
實例化
bufio 包提供了兩個實例化 bufio.Reader 對象的函數：NewReader 和 NewReaderSize。其中，NewReader 函數是調用 NewReaderSize。
函數實現的：
// NewReader returns a new Reader whose buffer has the default size.
func NewReader(rd io.Reader) *Reader {
// defaultBufSize = 4096,默認的大小
return NewReaderSize(rd, defaultBufSize)
}
調用的NewReaderSize
// NewReaderSize returns a new Reader whose buffer has at least the specified
// size. If the argument io.Reader is already a Reader with large enough
// size, it returns the underlying 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 {
size = minReadBufferSize
}
r := new(Reader)
r.reset(make([]byte, size), rd)
return r
}
ReadSlice
// ReadSlice reads until the first occurrence of delim in the input,
// returning a slice pointing at the bytes in the buffer.
// The bytes stop being valid at the next read.
// If ReadSlice encounters an error before finding a delimiter,
// it returns all the data in the buffer and the error itself (often io.EOF).
// ReadSlice fails with error ErrBufferFull if the buffer fills without a delim.
// Because the data returned from ReadSlice will be overwritten
// by the next I/O operation, most clients should use
// ReadBytes or ReadString instead.
// ReadSlice returns err != nil if and only if line does not end in delim.
ReadSlice需要放置一個界定符號，來分割
reader := bufio.NewReader(strings.NewReader("hello \n world"))
line, _ := reader.ReadSlice('\n')
fmt.Printf("the line:%s\n", line)
line, _ = reader.ReadSlice('\n')
fmt.Printf("the line:%s\n", line)
輸出
the line:hello
the line: world
ReadSlice 從輸入中讀取，直到遇到第一個界定符（delim）為止，返回一個指向緩存中字節的 slice，在下次調用讀操作（read）時，這些字節會無效
ReadString
ReadString是通過調用ReadBytes來實現的，看下源碼：
func (b *Reader) ReadString(delim byte) (string, error) {
bytes, err := b.ReadBytes(delim)
return string(bytes), err
}
使用例子：
reader := bufio.NewReader(strings.NewReader("hello \n world"))
line1, _ := reader.ReadString('\n')
fmt.Printf("the line1:%s\n", line1)
line2, _ := reader.ReadString('\n')
fmt.Printf("the line2:%s\n", line2)
ReadLine
根據官方的解釋這個是不推薦使用的，推薦使用ReadBytes('\n') or ReadString('\n')來替代。
ReadLine嘗試返回單獨的行，不包括行尾的換行符。如果一行大於緩存，isPrefix會被設置為true，同時返回該行的開始部分（等於緩存大小的部分）。該行剩余的部分就會在下次調用的時候返回。當下次調用返回該行剩余部分時，isPrefix將會是false。跟ReadSlice一樣，返回的line只是buffer的引用，在下次執行IO操作時，line會無效。
reader := bufio.NewReader(strings.NewReader("hello \n world"))
line1, _, _ := reader.ReadLine()
fmt.Printf("the line1:%s\n", line1)
line2, _, _ := reader.ReadLine()
fmt.Printf("the line2:%s\n", line2)
Peek
Peek只是查看下Reader有沒有讀取的n個字節。相比於ReadSlice，是並發安全的。因為ReadSlice返回的[]byte只是buffer中的引用，在下次IO操作后會無效。
func main() {
reader := bufio.NewReaderSize(strings.NewReader("hello world"), 12)
go Peek(reader)
go reader.ReadBytes('d')
time.Sleep(1e8)
}
func Peek(reader *bufio.Reader) {
line, _ := reader.Peek(5)
fmt.Printf("%s\n", line)
time.Sleep(1)
fmt.Printf("%s\n", line)
}
Scanner
bufio.Reader結構體中所有讀取數據的方法，都包含了delim分隔符，這個用起來很不方便，所以Google對此在go1.1版本中加入了bufio.Scanner結構體，用於讀取數據。
type Scanner struct {
// 內含隱藏或非導出字段
}
Scanner類型提供了方便的讀取數據的接口，如從換行符分隔的文本里讀取每一行。
Scanner.Scan方法默認是以換行符\n，作為分隔符。如果你想指定分隔符，Go語言提供了四種方法，ScanBytes(返回單個字節作為一個 token), ScanLines(返回一行文本), ScanRunes(返回單個 UTF-8 編碼的 rune 作為一個 token)和ScanWords(返回通過“空格”分詞的單詞)。除了這幾個預定的，我們也可以自定義分割函數。
掃描會在抵達輸入流結尾、遇到的第一個I/O錯誤、token過大不能保存進緩沖時，不可恢復的停止。當掃描停止后，當前讀取位置可能會遠在最后一個獲得的token后面。需要更多對錯誤管理的控制或token很大，或必須從reader連續掃描的程序，應使用bufio.Reader代替。
input := "hello world"
scanner := bufio.NewScanner(strings.NewReader(input))
scanner.Split(bufio.ScanWords)
for scanner.Scan() {
fmt.Println(scanner.Text())
}
if err := scanner.Err(); err != nil {
fmt.Fprintln(os.Stderr, "reading input:", err)
}
Give me more data
緩沖區的默認 size 是 4096。如果我們指定了最小的緩存區的大小，當在讀取的過程中，如果指定的最小緩沖區的大小不足以放置讀取的內容，就會發生擴容，原則是新的長度是之前的兩倍。
input := "abcdefghijkl"
scanner := bufio.NewScanner(strings.NewReader(input))
split := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
fmt.Printf("%t\t%d\t%s\n", atEOF, len(data), data)
return 0, nil, nil
}
scanner.Split(split)
buf := make([]byte, 2)
scanner.Buffer(buf, bufio.MaxScanTokenSize)
for scanner.Scan() {
fmt.Printf("%s\n", scanner.Text())
}
輸出
false 2 ab
false 4 abcd
false 8 abcdefgh
false 12 abcdefghijkl
true 12 abcdefghijkl
上面的長度是從2開始的，然后是倍數擴增，直到讀取完全部的數據，但是擴增的長度還是小於最大的默認長度4096。
Error
func (s *Scanner) Err() error
Err返回Scanner遇到的第一個非EOF的錯誤。
func main() {
// Comma-separated list; last entry is empty.
const input = "1,2,3,4,"
scanner := bufio.NewScanner(strings.NewReader(input))
// Define a split function that separates on commas.
onComma := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
for i := 0; i < len(data); i++ {
if data[i] == ',' {
return i + 1, data[:i], nil
}
}
if !atEOF {
return 0, nil, nil
}
// There is one final token to be delivered, which may be the empty string.
// Returning bufio.ErrFinalToken here tells Scan there are no more tokens after this
// but does not trigger an error to be returned from Scan itself.
return 0, data, bufio.ErrFinalToken
}
scanner.Split(onComma)
// Scan.
for scanner.Scan() {
fmt.Printf("%q ", scanner.Text())
}
if err := scanner.Err(); err != nil {
fmt.Fprintln(os.Stderr, "reading input:", err)
}
}
輸出
"1" "2" "3" "4" ""
Writer 對象
bufio.Write(p []byte) 的思路如下:
1、判斷buf中可用容量是否能放下p，如能放下直接存放進去。
2、如果可用容量不能放下，然后判斷當前buf是否是空buf。
3、如果是空buf，直接把p寫入到文件中。
4、如果buf不為空，使用p把buf填滿然后把buf寫入到文件中。
5、然后重復1。
// 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) {
// p的長度大於buf的可用容量
for len(p) > b.Available() && b.err == nil {
var n int
// buff中內容為空，直接操作p寫入到文件中
if b.Buffered() == 0 {
// Large write, empty buffer.
// Write directly from p to avoid copy.
n, b.err = b.wr.Write(p)
} else {
// 如果buff里面內容不是空，使用p填充buff，然后更新buff內容到文件中
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
}
// p的長度小於，buff的可用容量，直接存放到buff中即可
n := copy(b.buf[b.n:], p)
b.n += n
nn += n
return nn, nil
}
實例化
和 Reader 類型一樣，bufio 包提供了兩個實例化 bufio.Writer 對象的函數：NewWriter 和 NewWriterSize。其中，NewWriter 函數是調用 NewWriterSize 函數實現的：
// NewWriter returns a new Writer whose buffer has the default size.
func NewWriter(w io.Writer) *Writer {
// defaultBufSize = 4096
return NewWriterSize(w, defaultBufSize)
}
NewWriterSize:
// NewWriterSize returns a new Writer whose buffer has at least the specified
// size. If the argument io.Writer is already a Writer with large enough
// size, it returns the underlying Writer.
func NewWriterSize(w io.Writer, size int) *Writer {
// Is it already a Writer?
b, ok := w.(*Writer)
if ok && len(b.buf) >= size {
return b
}
if size <= 0 {
size = defaultBufSize
}
return &Writer{
buf: make([]byte, size),
wr: w,
}
}
Available
Available 方法獲取緩存中還未使用的字節數（緩存大小 - 字段 n 的值）
Buffered
Buffered 方法獲取寫入當前緩存中的字節數（字段 n 的值）
Flush
該方法將緩存中的所有數據寫入底層的 io.Writer 對象中。使用 bufio.Writer 時，在所有的 Write 操作完成之后，應該調用 Flush 方法使得緩存都寫入 io.Writer 對象中。
// Flush writes any buffered data to the underlying io.Writer.
func (b *Writer) Flush() error {
if b.err != nil {
return b.err
}
if b.n == 0 {
return nil
}
n, err := b.wr.Write(b.buf[0:b.n])
if n < b.n && err == nil {
err = io.ErrShortWrite
}
if err != nil {
if n > 0 && n < b.n {
copy(b.buf[0:b.n-n], b.buf[n:b.n])
}
b.n -= n
b.err = err
return err
}
b.n = 0
return nil
}
寫入的方法
// 實現了 io.ReaderFrom 接口
func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)
// 實現了 io.Writer 接口
func (b *Writer) Write(p []byte) (nn int, err error)
// 實現了 io.ByteWriter 接口
func (b *Writer) WriteByte(c byte) error
// io 中沒有該方法的接口，它用於寫入單個 Unicode 碼點，返回寫入的字節數（碼點占用的字節），內部實現會根據當前 rune 的范圍調用 WriteByte 或 WriteString
func (b *Writer) WriteRune(r rune) (size int, err error)
// 寫入字符串，如果返回寫入的字節數比 len(s) 小，返回的error會解釋原因
func (b *Writer) WriteString(s string) (int, error)
使用的demo
var s = bytes.NewBuffer([]byte{})
var w = bufio.NewWriter(s)
w.WriteString("hello world")
w.WriteString("你好")
fmt.Printf("string--%s", s.String())
fmt.Println()
w.Flush()
fmt.Printf("string--%s", s.String())
輸出
string--
string--hello world你好
ReadWriter
ReadWriter 結構存儲了 bufio.Reader 和 bufio.Writer 類型的指針（內嵌），它實現了 io.ReadWriter 結構。
type ReadWriter struct {
*Reader
*Writer
}
ReadWriter 的實例化可以跟普通結構類型一樣，也可以通過調用 bufio.NewReadWriter 函數來實現：只是簡單的實例化 ReadWriter
func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
return &ReadWriter{r, w}
}
總結
bufio中的Writer和Reader實現了帶緩存的I/O。其中關於Reader中的操作，都需要一個界定符號，推薦使用ReadBytes or ReadString，不推薦使用ReadLine。ReadSlice 從輸入中讀取，直到遇到第一個界定符（delim）為止，返回一個指向緩存中字節的 slice，在下次調用讀操作（read）時，這些字節會無效，所以我們要慎用，並發讀取的時候可能存在問題。在 Reader 類型中，感覺沒有讓人特別滿意的方法。於是，Go1.1增加了一個類型：Scanner。我們一般在讀取數據到緩沖區時，且想要采用分隔符分隔數據流時，我們一般使用bufio.Scanner數據結構，而不使用bufio.Reader。但是，需要更多對錯誤管理的控制或token很大，或必須從reader連續掃描的程序，應使用bufio.Reader代替。對於Writer的使用，我們不要忘記最后的Flush操作。