GO bufio解读

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
}

Reader的作用是为io.Reader提供一个buffer。Go提供了两个构造函数来创建Reader。

func NewReaderSize(rd io.Reader, size int) *Reader
func NewReader(rd io.Reader) *Reader

func NewReaderSize(rd io.Reader, size int) *Reader
如果rd本身就是Reader实例，并且len(rd.buf) >= size, 那么直接以rd作为返回值
如果size < 16, 返回一个buf长度为16的新Reader实例

func NewReader(rd io.Reader) *Reader
相当于NewReaderSize(rd, 4096)

其他操作函数解释如下：

func (b *Reader) Size() int  // 返回Reader中buf切片的长度
func (b *Reader) Reset(r io.Reader)  // 重置Reader中的rd，并将lastByte和lastRuneByte设为-1
func (b *Reader) Peek(n int) ([]byte, error) //从buf中取出n个字节。其与Read的不同点在于，Peek后不能执行UnreadByte和UnreadRune。因为Peek执行后会将lastByte和lastRuneSize置为-1，UnreadByte和UnreadRune执行时会先检查这两个字段，如果为-1则报错
func (b *Reader) Discard(n int) (discarded int, err error) // 抛弃未读的n字节数据，实质是将r向后移动n个位置
func (b *Reader) Read(p []byte) (n int, err error) //读取buf中的数据并写入到p中，返回实际读取的字节数。如果读到文件末尾，err将被设置为io.EOF
func (b *Reader) ReadByte() (byte, error) //读一个字节
func (b *Reader) UnreadByte() error //将上一个读取的字节置为unread，即将r向前移动一位。UnreadByte只能在Read或ReadByte操作后执行
func (b *Reader) ReadRune() (r rune, size int, err error) // 读取一个rune
func (b *Reader) UnreadRune() error //将上一个读取的rune置为unread，即将r向前移动一个rune字节数的位置（一般为1和3）
func (b *Reader) Buffered() int // 返回未读字节数，即r和w之间的距离
func (b *Reader) ReadSlice(delim byte) (line []byte, err error) // 读取一个切片，这个切片的最后一个字节是delim
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) //读取一行，相当于ReadSlice('\n')，但是此函数会处理掉行末的'\r'和'\n'
func (b *Reader) ReadBytes(delim byte) ([]byte, error) // 读取delim及其之前的所有未读字节。实现是调用了ReadSlice，但是如果在调用ReadSlice时，ReadSlice返回非“缓存区满”的错误，就将一直调用ReadSlice读下去
func (b *Reader) ReadString(delim byte) (string, error) //调用ReadBytes读取数据，然后转换为字符串
func (b *Reader) WriteTo(w io.Writer) (n int64, err error) // 将buf中的数据写入到io.Writer中去

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
}

Writer的作用是为io.Writer提供一个Buffer。
和Reader类似，Go提供两个Writer的构造函数

func NewWriterSize(w io.Writer, size int) *Writer
func NewWriter(w io.Writer) *Writer              // 相当于NewWriterSize(w, 4096)

func NewWriterSize(w io.Writer, size int) *Writer
如果w本身就是Writer实例，并且len(w.buf) >= size, 则直接将w转换为Write类型后返回
如果size <= 0, 设置size为4096

其他操作函数如下：

func (b *Writer) Size() int
func (b *Writer) Reset(w io.Writer)
func (b *Writer) Flush() error      // 将所有数据写入到io.Writer中, n置为0
func (b *Writer) Available() int    // 返回剩余缓存空间字节数
func (b *Writer) Buffered() int     // 返回缓存的字节数
func (b *Writer) Write(p []byte) (nn int, err error)  // 将p复制到buf中。如果p比剩余缓存区大，则直接将p写入到io.Writer中（buf也会被Flush），直到p中剩余数据比buf剩余缓存区小后将p剩余数据复制到buf中
func (b *Writer) WriteByte(c byte) error // 写入一个字节，如果缓存区已满，则Flush后再写入
func (b *Writer) WriteRune(r rune) (size int, err error)
func (b *Writer) WriteString(s string) (int, error) // 写入字符串
func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) // 从io.Reader中读取数据到buf中，如果buf读满了，Flush

ReadWriter

// ReadWriter stores pointers to a Reader and a Writer.
// It implements io.ReadWriter.
type ReadWriter struct {
    *Reader
    *Writer
}

// NewReadWriter allocates a new ReadWriter that dispatches to r and w.
func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
    return &ReadWriter{r, w}
}

Scanner

// Scanner provides a convenient interface for reading data such as
// a file of newline-delimited lines of text. Successive calls to
// the Scan method will step through the 'tokens' of a file, skipping
// the bytes between the tokens. The specification of a token is
// defined by a split function of type SplitFunc; the default split
// function breaks the input into lines with line termination stripped. Split
// functions are defined in this package for scanning a file into
// lines, bytes, UTF-8-encoded runes, and space-delimited words. The
// client may instead provide a custom split function.
//
// Scanning stops unrecoverably at EOF, the first I/O error, or a token too
// large to fit in the buffer. When a scan stops, the reader may have
// advanced arbitrarily far past the last token. Programs that need more
// control over error handling or large tokens, or must run sequential scans
// on a reader, should use bufio.Reader instead.
//
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.
    empties int // Count of successive empty tokens.
    scanCalled bool // Scan has been called; buffer is in use.
    done bool // Scan has finished.
}

Scanner的主要作用就是从文件读取数据
Scanner的具体操作方法如下：

func NewScanner(r io.Reader) *Scanner  // 构造函数
func (s *Scanner) Err() error // 返回任意非io.EOF的错误
func (s *Scanner) Bytes() []byte // 返回token中的所有字节
func (s *Scanner) Text() string // 相当于string(Bytes())
func (s *Scanner) Scan() bool // 判断是否有数据可以读取
func (s *Scanner) Buffer(buf []byte, max int) // 将s.buf中的数据写入到buf中
func (s *Scanner) Split(split SplitFunc) //设置拆分函数 s.split = split
func ScanBytes(data []byte, atEOF bool) (advance int, token []byte, err error) //获取一个字节作为一个token
func ScanRunes(data []byte, atEOF bool) (advance int, token []byte, err error) //获取一个rune作为一个token
func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error) //Scanner的默认拆分函数，获取一行（删除了\r\n）作为一个token
func ScanWords(data []byte, atEOF bool) (advance int, token []byte, err error) //按照空白字符拆分，取一串非空字符串作为一个token