Go_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)的内容，思路如下：

1. 当缓存区有内容的时，将缓存区内容全部填入p并清空缓存区

2. 当缓存区没有内容的时候且len(p)>len(buf),即要读取的内容比缓存区还要大，直接去文件读取即可

3. 当缓存区没有内容的时候且len(p)<len(buf),即要读取的内容比缓存区小，缓存区从文件读取内容充满缓存区，并将p填满（此时缓存区有剩余内容）

4. 以后再次读取时缓存区有内容，将缓存区内容全部填入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) 的思路如下

1. 判断buf中可用容量是否可以放下 p

2. 如果能放下，直接把p拼接到buf后面，即把内容放到缓冲区

3. 如果缓冲区的可用容量不足以放下，且此时缓冲区是空的，直接把p写入文件即可

4. 如果缓冲区的可用容量不足以放下，且此时缓冲区有内容，则用p把缓冲区填满，把缓冲区所有内容写入文件，并清空缓冲区

5. 判断p的剩余内容大小能否放到缓冲区，如果能放下（此时和步骤1情况一样）则把内容放到缓冲区

6. 如果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()
}