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)<len(buf),即要读取的内容比缓存区小，缓存区从文件读取内容充满缓存区，并将p填满（此时缓存区有剩余内容）
-
以后再次读取时缓存区有内容，将缓存区内容全部填入p并清空缓存区（此时和情况1一样）
package main
import (
"os"
"fmt"
"bufio"
)
func main() {
/*
bufio:高效io读写
buffer缓存
io：input/output
将io包下的Reader，Write对象进行包装，带缓存的包装，提高读写的效率
ReadBytes()
ReadString()
ReadLine()
*/
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() 不建议使用，太low了
data, flag, err := b1.ReadLine()
fmt.Println(flag)
fmt.Println(err)
fmt.Println(data)
fmt.Println(string(data))
//3.ReadString()
//读取一行，分隔符就是\n
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)
}
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的剩余内容直接写入文件
package main
import (
"os"
"fmt"
"bufio"
)
func main() {
/*
bufio:高效io读写
buffer缓存
io：input/output
将io包下的Reader，Write对象进行包装，带缓存的包装，提高读写的效率
func (b *Writer) Write(p []byte) (nn int, err error)
func (b *Writer) WriteByte(c byte) error
func (b *Writer) WriteRune(r rune) (size int, err error)
func (b *Writer) WriteString(s string) (int, error)
*/
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()
}