生命不止，继续Go go go。。
Go语言在io操作中，还提供了一个bufio的包，使用这个包可以大幅提高文件读写的效率。
一、bufio包原理
bufio 是通过缓冲来提高效率。
io操作本身的效率并不低，低的是频繁的访问本地磁盘的文件。所以bufio就提供了缓冲区(分配一块内存)，读和写都先在缓冲区中，最后再读写文件，来降低访问本地磁盘的次数，从而提高效率。
简单的说就是，把文件读取进缓冲（内存）之后再读取的时候就可以避免文件系统的io 从而提高速度。同理，在进行写操作时，先把文件写入缓冲（内存），然后由缓冲写入文件系统。看完以上解释有人可能会表示困惑了，直接把 内容->文件 和 内容->缓冲->文件相比， 缓冲区好像没有起到作用嘛。其实缓冲区的设计是为了存储多次的写入，最后一口气把缓冲区内容写入文件。
bufio 封装了io.Reader或io.Writer接口对象，并创建另一个也实现了该接口的对象。
io.Reader或io.Writer 接口实现read() 和 write() 方法，对于实现这个接口的对象都是可以使用这两个方法的。
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 // last byte read for UnreadByte; -1 means invalid lastRuneSize int // size of last rune read for UnreadRune; -1 means invalid}bufio.Read(p []byte) 相当于读取大小len(p)的内容，思路如下：
- 当缓存区有内容的时，将缓存区内容全部填入p并清空缓存区当缓存区没有内容的时候且len(p)>len(buf),即要读取的内容比缓存区还要大，直接去文件读取即可当缓存区没有内容的时候且len(p)
源码：
// 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 { 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.// If an error occurs writing to a Writer, no more data will be// accepted and all subsequent writes, and Flush, will return the error.// After all data has been written, the client should call the// Flush method to guarantee all data has been forwarded to// the underlying io.Writer.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的剩余内容依旧大于缓冲区，（注意此时缓冲区是空的，情况和步骤3一样）则把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大于缓存区
二、bufio包
bufio包实现了有缓冲的I/O。它包装一个io.Reader或io.Writer接口对象，创建另一个也实现了该接口，且同时还提供了缓冲和一些文本I/O的帮助函数的对象。
bufio.Reader：
bufio.Reader 实现了如下接口：
io.Reader
io.WriterTo
io.ByteScanner
io.RuneScanner
// NewReaderSize 将 rd 封装成一个带缓存的 bufio.Reader 对象，// 缓存大小由 size 指定（如果小于 16 则会被设置为 16）。// 如果 rd 的基类型就是有足够缓存的 bufio.Reader 类型，则直接将// rd 转换为基类型返回。func NewReaderSize(rd io.Reader, size int) *Reader// NewReader 相当于 NewReaderSize(rd, 4096)func NewReader(rd io.Reader) *Reader// Peek 返回缓存的一个切片，该切片引用缓存中前 n 个字节的数据，// 该操作不会将数据读出，只是引用，引用的数据在下一次读取操作之// 前是有效的。如果切片长度小于 n，则返回一个错误信息说明原因。// 如果 n 大于缓存的总大小，则返回 ErrBufferFull。func (b *Reader) Peek(n int) ([]byte, error)// Read 从 b 中读出数据到 p 中，返回读出的字节数和遇到的错误。// 如果缓存不为空，则只能读出缓存中的数据，不会从底层 io.Reader// 中提取数据，如果缓存为空，则：// 1、len(p) >= 缓存大小，则跳过缓存，直接从底层 io.Reader 中读// 出到 p 中。// 2、len(p) < 缓存大小，则先将数据从底层 io.Reader 中读取到缓存// 中，再从缓存读取到 p 中。func (b *Reader) Read(p []byte) (n int, err error)// Buffered 返回缓存中未读取的数据的长度。func (b *Reader) Buffered() int// ReadBytes 功能同 ReadSlice，只不过返回的是缓存的拷贝。func (b *Reader) ReadBytes(delim byte) (line []byte, err error)// ReadString 功能同 ReadBytes，只不过返回的是字符串。func (b *Reader) ReadString(delim byte) (line string, err error)...
bufio.Writer：
bufio.Writer 实现了如下接口：
io.Writer
io.ReaderFrom
io.ByteWriter
// NewWriterSize 将 wr 封装成一个带缓存的 bufio.Writer 对象，// 缓存大小由 size 指定（如果小于 4096 则会被设置为 4096）。// 如果 wr 的基类型就是有足够缓存的 bufio.Writer 类型，则直接将// wr 转换为基类型返回。func NewWriterSize(wr io.Writer, size int) *Writer// NewWriter 相当于 NewWriterSize(wr, 4096)func NewWriter(wr io.Writer) *Writer// WriteString 功能同 Write，只不过写入的是字符串func (b *Writer) WriteString(s string) (int, error)// WriteRune 向 b 写入 r 的 UTF-8 编码，返回 r 的编码长度。func (b *Writer) WriteRune(r rune) (size int, err error)// Flush 将缓存中的数据提交到底层的 io.Writer 中func (b *Writer) Flush() error// Available 返回缓存中未使用的空间的长度func (b *Writer) Available() int// Buffered 返回缓存中未提交的数据的长度func (b *Writer) Buffered() int// Reset 将 b 的底层 Writer 重新指定为 w，同时丢弃缓存中的所有数据，复位// 所有标记和错误信息。相当于创建了一个新的 bufio.Writer。func (b *Writer) Reset(w io.Writer)...
三、实例代码
读取数据：
package mainimport ( "os" "fmt" "bufio")func main() { fileName:="/Users/ruby/documents/pro/a/english.txt" file,err := os.Open(fileName) if err != nil{ fmt.Println(err) return } defer file.Close() //创建Reader对象 //b1 := bufio.NewReader(file) //1.Read()，高效读取 //p := make([]byte,1024) //n1,err := b1.Read(p) //fmt.Println(n1) //fmt.Println(string(p[:n1])) //2.ReadLine() //data,flag,err := b1.ReadLine() //fmt.Println(flag) //fmt.Println(err) //fmt.Println(data) //fmt.Println(string(data)) //3.ReadString() // s1,err :=b1.ReadString('n') // fmt.Println(err) // fmt.Println(s1) // // s1,err = b1.ReadString('n') // fmt.Println(err) // fmt.Println(s1) // //s1,err = b1.ReadString('n') //fmt.Println(err) //fmt.Println(s1) // //for{ // s1,err := b1.ReadString('n') // if err == io.EOF{ // fmt.Println("读取完毕。。") // break // } // fmt.Println(s1) //} //4.ReadBytes() //data,err :=b1.ReadBytes('n') //fmt.Println(err) //fmt.Println(string(data)) //Scanner //s2 := "" //fmt.Scanln(&s2) //fmt.Println(s2) b2 := bufio.NewReader(os.Stdin) s2, _ := b2.ReadString('n') fmt.Println(s2)}本地文件：english.txt文件内容：
写数据示例代码：
package mainimport ( "os" "fmt" "bufio")func main() { fileName := "/Users/ruby/documents/pro/a/cc.txt" file,err := os.OpenFile(fileName,os.O_CREATE|os.O_WRONLY,os.ModePerm) if err != nil{ fmt.Println(err) return } defer file.Close() w1 := bufio.NewWriter(file) //n,err := w1.WriteString("helloworld") //fmt.Println(err) //fmt.Println(n) //w1.Flush() //刷新缓冲区 for i:=1;i<=1000;i++{ w1.WriteString(fmt.Sprintf("%d:hello",i)) } w1.Flush()}
