bufio模块实例及代码分析

bufio模块是golang标准库中的模块之一，主要是实现了一个读写的缓存，用于对数据的读取或者写入操作。该模块在多个涉及io的标准库中被使用，比如http模块中使用buffio来完成网络数据的读写，压缩文件的zip模块利用bufio来操作文件数据的读写等。本篇文章主要是通过两个例子简单的介绍bufio的一些功能和实现方式，供大家参考。

复制文件

复制一个文件内容到另一个文件中，我们如果直接使用ioutil包中的ReadFile和WriteFile的确可以直接两行就解决这个问题，但是ReadFile的方式会将整个的文件读取到内存中，等待写入到文件，所以对于大的文件处理上面可能存在一些问题，比如系统内存过小，导致写入后整个内存被占满。

我们使用bufio的方式读取的时候，模块会记录我们读取的位置，逐步的将数据从原始文件转移到新创建的文件中，代码如下：

func main() {
    fileInput, err := os.Open("file.txt")
    if err != nil {
        panic(err)
    }
    defer func() {
        if err = fileInput.Close(); err != nil {
            panic(err)
        }
    }()
    readBuffer := bufio.NewReader(fileInput)
    fileOutput, err := os.Create("output.txt")
    if err != nil {
        panic(err)
    }
    defer func() {
        if err := fileOutput.Close(); err != nil {
            panic(err)
        }
    }()
    writeBuffer := bufio.NewWriter(fileOutput)
    buf := make([]byte, 1024)
    for {
        n, err := readBuffer.Read(buf)
        if err != nil && err != io.EOF {
            panic(err)
        }
        if n == 0 {
            break
        }
        if _, err := writeBuffer.Write(buf[:n]); err != nil {
            panic(err)
        }
    }
    if err = writeBuffer.Flush(); err != nil {
        panic(err)
    }
}

上述代码中我们分别创建了一个bufio.Reader和一个bufio.Writer用来从文件读取数据和写入数据到指定文件。注意其中关闭文件的操作我们放入了一个defer中，而在defer中我们也进行了判断，这里主要是为了防止Close()出现错误的时候，导致文件写入的时候不完整问题（close执行的时候可能会将上一个操作的错误返回）。

上述代码中for循环不断的从我们定义的Reader中读取数据到buf数组中，然后判断是否出现错误，如果未出现错误则通过Writer写入到文件中。每一步我们都加入了错误的判断，防止出现文件读写错误。最后我们调用Fluse()来刷新数据，确保所有的数据都已经写入到Writer中。

这里的Write()和Read()函数分别来自于bufio模块操作函数，另外由于*File实现了io.Writer接口和io.Reader接口所以可以传递到结构体bufio.Writer中,结构体的定义如下：

type Writer struct {
    err error
    buf []byte
    n   int
    wr  io.Writer
}

func NewWriterSize(w io.Writer, size int) *Writer {
    // Is it already a Writer?
    b, ok := w.(*Writer)
    if ok && len(b.buf) >= size {
        return b
    }
    if size <= 0 {
        size = defaultBufSize
    }
    return &Writer{
        buf: make([]byte, size),
        wr:  w,
    }
}

// NewWriter returns a new Writer whose buffer has the default size.
func NewWriter(w io.Writer) *Writer {
    return NewWriterSize(w, defaultBufSize)
}

另外我们在向文件写入数据的时候，调用的Write()函数，通过一些检查最终将数据从buf数组中写入文件中。其中检查需要写入的数据是否大于可以接收的尺寸，通过for循环一步步的将数据写完。如下是bufio.Write的代码：

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
}

对于Read的操作基本上一致,bufio.Reader结构体内部维护一个buf和一个io.Reader结构体，并且保存读取数据的位置r和w.在缓存数据的过程中，bufio也基本上是尽量避免进行copy操作而选择直接读取数据，这样会降低整个的操作过程中的资源消耗。

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()
        }
        b.fill() // buffer is empty
        if b.r == b.w {
            return 0, b.readErr()
        }
    }

    // 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
}

逐行读取文件

这个实例中我们选择逐行去读取文本中的文件，不过这次我们不是直接调用Read去读取数据而是通过另一个接口创建一个Scanner对象来扫描文件,代码如下：

unc main() {
    file, err := os.Open("file.txt")
    if err != nil {
        panic("File open error" + err.Error())
    }
    defer func() {
        if err = file.Close(); err != nil {
            panic(err)
        }
    }()

    fileScanner := bufio.NewScanner(file)
    for fileScanner.Scan() {
        fmt.Println(fileScanner.Text())
    }
    if err = fileScanner.Err(); err != nil {
        log.Panicf("Scan error:%s", err)
    }
}

代码中我们打开文件后将文件指针传递到bufio.NewScanner来生成一个Scanner对象，这个对象的主要目的就是通过一定的规则来读取对象数据，对数据进行切分，在内部使用token来标记每一个的切分数据，如下为定义的Scanner结构体和初始化函数.

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.
}


func NewScanner(r io.Reader) *Scanner {
    return &Scanner{
        r:            r,
        split:        ScanLines,
        maxTokenSize: MaxScanTokenSize,
        buf:          make([]byte, 4096), // Plausible starting size; needn't be large.
    }
}

默认的切分函数是ScanLines，正如函数名描述的那样，这个函数会将输入的[]byte数据根据‘\n’来进行划分，一旦监测到中间包含有该切分符号则返回切分之前的数据，以及当前的读取位置值。

func ScanLines(data []byte, atEOF bool) (advance int, token []byte, err error) {
    if atEOF && len(data) == 0 {
        return 0, nil, nil
    }
    if i := bytes.IndexByte(data, '\n'); i >= 0 {
        // We have a full newline-terminated line.
        return i + 1, dropCR(data[0:i]), nil
    }
    // If we're at EOF, we have a final, non-terminated line. Return it.
    if atEOF {
        return len(data), dropCR(data), nil
    }
    // Request more data.
    return 0, nil, nil
}

接下里的Scan函数则是不断的循环获得切分出来的token值（每一个切分数据）并利用Text()函数将其打印出来。另外除了ScanLines外，标准库中还提供了ScanBytes, ScanRunes,ScanWords等，可以直接使用否则默认情况是按照行进行切分。