发表于

简介

bufio 包实现了缓存IO。它包装了 io.Reader 和 io.Writer 对象，创建了另外的Reader和Writer对象，它们也实现了io.Reader和io.Writer接口，不过它们是有缓存的。该包同时为文本I/O提供了一些便利操作。

Reader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
type Reader struct {
    buf          []byte     // 缓存
    rd           io.Reader  // 底层的io.Reader
    // r:从buf中读走的字节（偏移）；w:buf中填充内容的偏移；
    // w - r 是buf中可被读的长度（缓存数据的大小），也是Buffered()方法的返回值
    r, w         int
    err          error      // 读过程中遇到的错误
    lastByte     int        // 最后一次读到的字节（ReadByte/UnreadByte)
    lastRuneSize int        // 最后一次读到的Rune的大小(ReadRune/UnreadRune)
}
func NewReader(rd io.Reader) *Reader
func NewReaderSize(rd io.Reader, size int) *Reader  //NewReader的实际调用
func (b *Reader) ReadSlice(delim byte) (line []byte, err error) //不推荐 返回的line是指向Reader中的buffer，而不是copy一份返回 应使用ReadBytes或ReadString line包括界定符
func (b *Reader) ReadBytes(delim byte) (line []byte, err error) //只要不以delim结尾 err就一定不为nil line是buf的copy line包括界定符
func (b *Reader) ReadString(delim byte) (line string, err error) //底层调用ReadBytes 返回将[]byte转为string
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) //不推荐 按行读取 推荐使用Scanner
func (b *Reader) Peek(n int) ([]byte, error)    //“窥探”一下Reader中没有读取的n个字节。好比栈数据结构中的取栈顶元素，但不出栈
//实现io包中的接口
func (b *Reader) Read(p []byte) (n int, err error) 读取len(p)个字节至p中
func (b *Reader) ReadByte() (c byte, err error) 读取单个字节
func (b *Reader) ReadRune() (r rune, size int, err error)
func (b *Reader) UnreadByte() error 重置上一次的ReadByte
func (b *Reader) UnreadRune() error 重置上一次的ReadRune
func (b *Reader) WriteTo(w io.Writer) (n int64, err error)

Scanner

对于简单的读取一行，在Reader类型中，感觉没有让人特别满意的方法。于是，Go1.1增加了一个类型：Scanner
在 bufio 包中有多种方式获取文本输入，ReadBytes、ReadString 和独特的 ReadLine，对于简单的目的这些都有些过于复杂了。在 Go 1.1 中，添加了一个新类型，Scanner，以便更容易的处理如按行读取输入序列或空格分隔单词等，这类简单的任务。它终结了如输入一个很长的有问题的行这样的输入错误，并且提供了简单的默认行为：基于行的输入，每行都剔除分隔标识

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
type Scanner struct {
    r            io.Reader // The reader provided by the client.
    split        SplitFunc // The function to split the tokens.
    maxTokenSize int       // Maximum size of a token; modified by tests.
    token        []byte    // Last token returned by split.
    buf          []byte    // Buffer used as argument to split.
    start        int       // First non-processed byte in buf.
    end          int       // End of data in buf.
    err          error     // Sticky error.
}
func NewScanner(r io.Reader) *Scanner
func (s *Scanner) Scan() bool
func (s *Scanner) Split(split SplitFunc)        //设定分词策略 默认bufio.SplitLines按行分词 另有SplitWords按词分 SplitRunes单个utf8字符 SplitBytes单个字符
func (s *Scanner) Text() string
func (s *Scanner) Bytes() []byte                //同Text 只不过返回值是[]byte
func (s *Scanner) Err() error

Writer

bufio.Writer 结构包装了一个 io.Writer 对象，提供缓存功能，同时实现了 io.Writer 接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
type Writer struct {
    err error       // 写过程中遇到的错误
    buf []byte      // 缓存
    n   int         // 当前缓存中的字节数
    wr  io.Writer   // 底层的 io.Writer 对象
}
func NewWriter(w io.Writer) *Writer
func NewWriterSize(wr io.Writer, size int) *Writer  //NewWriter的实际调用
func (b *Writer) Available() int    //方法获取缓存中还未使用的字节数（缓存大小 - 字段 n 的值
func (b *Writer) Buffered() int     //方法获取写入当前缓存中的字节数（字段 n 的值）
func (b *Writer) Flush() error      //该方法将缓存中的所有数据写入底层的 io.Writer 对象中。使用 bufio.Writer 时，在所有的 Write 操作完成之后，应该调用 Flush 方法使得缓存都写入 io.Writer 对象中。
func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)
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)

参考

bufio — 缓存IO