首页 › Go语言论坛 › go中bufio使用小结

四分之一的幸福 發表於 2020-6-24 16:29:00

go中bufio使用小结

<ul>
<li>bufio
<ul>
<li>前言</li>
<li>例子</li>
<li>bufio
<ul>
<li>源码解析</li>
<li>Reader对象
<ul>
<li>实例化</li>
<li>ReadSlice</li>
<li>ReadString</li>
<li>ReadLine</li>
<li>Peek</li>
</ul>
</li>
<li>Scanner
<ul>
<li>Give me more data</li>
<li>Error</li>
</ul>
</li>
<li>Writer 对象
<ul>
<li>实例化</li>
<li>Available</li>
<li>Buffered</li>
<li>Flush</li>
<li>写入的方法</li>
<li>ReadWriter</li>
</ul>
</li>
</ul>
</li>
<li>总结</li>
</ul>
</li>
</ul>

<h2 id="bufio">bufio</h2>
<h3 id="前言">前言</h3>
<p>最近操作文件，进行优化使用到了<code>bufio</code>。好像也不太了解这个，那么就梳理下，<code>bufio</code>的使用。</p>
<h3 id="例子">例子</h3>
<p>我的场景：使用<code>xml</code>拼接了<code>office2003</code>的文档。写入到<code>buffer</code>，然后处理完了，转存到文件里面。</p>
<pre><code class="language-go">type Buff struct {
        Buffer *bytes.Buffer
        Writer *bufio.Writer
}

// 初始化
func NewBuff() *Buff {
        b := bytes.NewBuffer([]byte{})
        return &amp;Buff{
                Buffer: b,
                Writer: bufio.NewWriter(b),
        }
}

func (b *Buff) WriteString(str string) error {
        _, err := b.Writer.WriteString(str)
        return err
}

func (b *Buff) SaveAS(name string) error {
        file, err := os.OpenFile(name, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0666)
        if err != nil {
                return err
        }
        defer file.Close()

        if err := b.Writer.Flush(); err != nil {
                return nil
        }

        _, err = b.Buffer.WriteTo(file)
        return err
}

func main() {
        var b = NewBuff()

        b.WriteString("haah")
}
</code></pre>
<h3 id="bufio-1">bufio</h3>
<blockquote>
<p>Package bufio implements buffered I/O. It wraps an io.Reader or io.Writer object, creating another object (Reader or Writer) that also implements the interface but provides buffering and some help for textual I/O.</p>
</blockquote>
<p><code>bufio</code>包实现了有缓冲的<code>I/O</code>。它包装一个<code>io.Reader</code>或<code>io.Writer</code>接口对象，创建另一个也实现了该接口，且同时还提供了缓冲和一些文本<code>I/O</code>的帮助函数的对象。</p>
<p>简单的说就是<code>bufio</code>会把文件内容读取到缓存中（内存），然后再取读取需要的内容的时候，直接在缓存中读取，避免文件的<code>i/o</code>操作。同样，通过<code>bufio</code>写入内容，也是先写入到缓存中（内存），然后由缓存写入到文件。避免多次小内容的写入操作<code>I/O</code>。</p>
<h4 id="源码解析">源码解析</h4>
<h4 id="reader对象">Reader对象</h4>
<p>bufio.Reader 是bufio中对io.Reader 的封装</p>
<pre><code class="language-go">// Reader implements buffering for an io.Reader object.
type Reader struct {
        buf          []byte
        rd         io.Reader // 底层的io.Reader
        r, w         int       // r:从buf中读走的字节（偏移）；w:buf中填充内容的偏移；
                               // w - r 是buf中可被读的长度（缓存数据的大小），也是Buffered()方法的返回值
        err          error
        lastByte   int // 最后一次读到的字节（ReadByte/UnreadByte)
        lastRuneSize int // 最后一次读到的Rune的大小(ReadRune/UnreadRune)
}
</code></pre>
<p>bufio.Read(p []byte) 的思路如下：</p>
<p>1、当缓存区有内容的时，将缓存区内容全部填入p并清空缓存区<br>
2、当缓存区没有内容的时候且len(p)&gt;len(buf),即要读取的内容比缓存区还要大，直接去文件读取即可<br>
3、当缓存区没有内容的时候且len(p)&lt;len(buf),即要读取的内容比缓存区小，缓存区从文件读取内容充满缓存区，并将p填满（此时缓存区有剩余内容）<br>
4、以后再次读取时缓存区有内容，将缓存区内容全部填入p并清空缓存区（此时和情况1一样）</p>
<p><img src="https://img2020.cnblogs.com/blog/1237626/202006/1237626-20200624162830239-286787942.png" alt="" loading="lazy"></p>
<pre><code class="language-go">// Read reads data into p.
// It returns the number of bytes read into p.
// The bytes are taken from at most one Read on the underlying Reader,
// hence n may be less than len(p).
// To read exactly len(p) bytes, use io.ReadFull(b, p).
// At EOF, the count will be zero and err will be io.EOF.
func (b *Reader) Read(p []byte) (n int, err error) {
        n = len(p)
        if n == 0 {
                if b.Buffered() &gt; 0 {
                        return 0, nil
                }
                return 0, b.readErr()
        }
        // r:从buf中读走的字节（偏移）；w:buf中填充内容的偏移；
        // w - r 是buf中可被读的长度（缓存数据的大小），也是Buffered()方法的返回值
        // b.r == b.w 表示，当前缓冲区里面没有内容
        if b.r == b.w {
                if b.err != nil {
                        return 0, b.readErr()
                }
                // 如果p的大小大于等于缓冲区大小，则直接将数据读入p，然后返回
                if len(p) &gt;= len(b.buf) {
                        // Large read, empty buffer.
                        // Read directly into p to avoid copy.
                        n, b.err = b.rd.Read(p)
                        if n &lt; 0 {
                                panic(errNegativeRead)
                        }
                        if n &gt; 0 {
                                b.lastByte = int(p)
                                b.lastRuneSize = -1
                        }
                        return n, b.readErr()
                }
                // buff容量大于p，直接将buff中填满
                // One read.
                // Do not use b.fill, which will loop.
                b.r = 0
                b.w = 0
                n, b.err = b.rd.Read(b.buf)
                if n &lt; 0 {
                        panic(errNegativeRead)
                }
                if n == 0 {
                        return 0, b.readErr()
                }
                b.w += n
        }

        // copy缓存区的内容到p中（填充满p）
        // copy as much as we can
        n = copy(p, b.buf)
        b.r += n
        b.lastByte = int(b.buf)
        b.lastRuneSize = -1
        return n, nil
}
</code></pre>
<h5 id="实例化">实例化</h5>
<p><code>bufio</code> 包提供了两个实例化 <code>bufio.Reader</code> 对象的函数：<code>NewReader</code> 和 <code>NewReaderSize</code>。其中，<code>NewReader</code> 函数是调用 <code>NewReaderSize</code>。<br>
函数实现的：</p>
<pre><code>// NewReader returns a new Reader whose buffer has the default size.
func NewReader(rd io.Reader) *Reader {
    // defaultBufSize = 4096,默认的大小
        return NewReaderSize(rd, defaultBufSize)
}
</code></pre>
<p>调用的<code>NewReaderSize</code></p>
<pre><code class="language-go">// NewReaderSize returns a new Reader whose buffer has at least the specified
// size. If the argument io.Reader is already a Reader with large enough
// size, it returns the underlying Reader.
func NewReaderSize(rd io.Reader, size int) *Reader {
        // Is it already a Reader?
        b, ok := rd.(*Reader)
        if ok &amp;&amp; len(b.buf) &gt;= size {
                return b
        }
        if size &lt; minReadBufferSize {
                size = minReadBufferSize
        }
        r := new(Reader)
        r.reset(make([]byte, size), rd)
        return r
}
</code></pre>
<h5 id="readslice">ReadSlice</h5>
<p>// ReadSlice reads until the first occurrence of delim in the input,<br>
// returning a slice pointing at the bytes in the buffer.<br>
// The bytes stop being valid at the next read.<br>
// If ReadSlice encounters an error before finding a delimiter,<br>
// it returns all the data in the buffer and the error itself (often io.EOF).<br>
// ReadSlice fails with error ErrBufferFull if the buffer fills without a delim.<br>
// Because the data returned from ReadSlice will be overwritten<br>
// by the next I/O operation, most clients should use<br>
// ReadBytes or ReadString instead.<br>
// ReadSlice returns err != nil if and only if line does not end in delim.</p>
<p><code>ReadSlice</code>需要放置一个界定符号，来分割</p>
<pre><code class="language-go">        reader := bufio.NewReader(strings.NewReader("hello \n world"))
        line, _ := reader.ReadSlice('\n')
        fmt.Printf("the line:%s\n", line)

        line, _ = reader.ReadSlice('\n')
        fmt.Printf("the line:%s\n", line)
</code></pre>
<p>输出</p>
<pre><code>the line:hello

the line: world
</code></pre>
<p><code>ReadSlice</code> 从输入中读取，直到遇到第一个界定符（delim）为止，返回一个指向缓存中字节的 slice，在下次调用读操作（read）时，这些字节会无效</p>
<h5 id="readstring">ReadString</h5>
<p><code>ReadString</code>是通过调用<code>ReadBytes</code>来实现的，看下源码：</p>
<pre><code class="language-go">func (b *Reader) ReadString(delim byte) (string, error) {
        bytes, err := b.ReadBytes(delim)
        return string(bytes), err
}
</code></pre>
<p>使用例子：</p>
<pre><code class="language-go">        reader := bufio.NewReader(strings.NewReader("hello \n world"))
        line1, _ := reader.ReadString('\n')
        fmt.Printf("the line1:%s\n", line1)

        line2, _ := reader.ReadString('\n')
        fmt.Printf("the line2:%s\n", line2)
</code></pre>
<h5 id="readline">ReadLine</h5>
<p>根据官方的解释这个是不推荐使用的，推荐使用<code>ReadBytes('\n')</code> or <code>ReadString('\n')</code>来替代。</p>
<p>ReadLine尝试返回单独的行，不包括行尾的换行符。如果一行大于缓存，isPrefix会被设置为true，同时返回该行的开始部分（等于缓存大小的部分）。该行剩余的部分就会在下次调用的时候返回。当下次调用返回该行剩余部分时，isPrefix将会是false。跟ReadSlice一样，返回的line只是buffer的引用，在下次执行IO操作时，line会无效。</p>
<pre><code class="language-go">        reader := bufio.NewReader(strings.NewReader("hello \n world"))
        line1, _, _ := reader.ReadLine()
        fmt.Printf("the line1:%s\n", line1)

        line2, _, _ := reader.ReadLine()
        fmt.Printf("the line2:%s\n", line2)
</code></pre>
<h5 id="peek">Peek</h5>
<p><code>Peek</code>只是查看下<code>Reader</code>有没有读取的n个字节。相比于<code>ReadSlice</code>，是并发安全的。因为<code>ReadSlice</code>返回的[]byte只是buffer中的引用，在下次IO操作后会无效。</p>
<pre><code class="language-go">func main() {
        reader := bufio.NewReaderSize(strings.NewReader("hello world"), 12)
        go Peek(reader)
        go reader.ReadBytes('d')
        time.Sleep(1e8)
}

func Peek(reader *bufio.Reader) {
        line, _ := reader.Peek(5)
        fmt.Printf("%s\n", line)
        time.Sleep(1)
        fmt.Printf("%s\n", line)
}
</code></pre>
<h4 id="scanner">Scanner</h4>
<p><code>bufio.Reader</code>结构体中所有读取数据的方法，都包含了<code>delim</code>分隔符，这个用起来很不方便，所以<code>Google</code>对此在go1.1版本中加入了<code>bufio.Scanner</code>结构体，用于读取数据。</p>
<pre><code class="language-go">type Scanner struct {
    // 内含隐藏或非导出字段
}
</code></pre>
<p>Scanner类型提供了方便的读取数据的接口，如从换行符分隔的文本里读取每一行。</p>
<p><code>Scanner.Scan</code>方法默认是以换行符<code>\n</code>，作为分隔符。如果你想指定分隔符，<code>Go</code>语言提供了四种方法，<code>ScanBytes</code>(返回单个字节作为一个 <code>token</code>), <code>ScanLines</code>(返回一行文本), <code>ScanRunes</code>(返回单个 <code>UTF-8</code> 编码的 <code>rune</code> 作为一个 <code>token</code>)和<code>ScanWords</code>(返回通过“空格”分词的单词)。除了这几个预定的，我们也可以自定义分割函数。</p>
<p>扫描会在抵达输入流结尾、遇到的第一个<code>I/O</code>错误、<code>token</code>过大不能保存进缓冲时，不可恢复的停止。当扫描停止后，当前读取位置可能会远在最后一个获得的<code>token</code>后面。需要更多对错误管理的控制或<code>token</code>很大，或必须从<code>reader</code>连续扫描的程序，应使用<code>bufio.Reader</code>代替。</p>
<pre><code class="language-go">        input := "hello world"
        scanner := bufio.NewScanner(strings.NewReader(input))
        scanner.Split(bufio.ScanWords)
        for scanner.Scan() {
                fmt.Println(scanner.Text())
        }
        if err := scanner.Err(); err != nil {
                fmt.Fprintln(os.Stderr, "reading input:", err)
        }
</code></pre>
<h5 id="give-me-more-data">Give me more data</h5>
<p>缓冲区的默认 <code>size</code> 是 4096。如果我们指定了最小的缓存区的大小，当在读取的过程中，如果指定的最小缓冲区的大小不足以放置读取的内容，就会发生扩容，原则是新的长度是之前的两倍。</p>
<pre><code class="language-go">input := "abcdefghijkl"
        scanner := bufio.NewScanner(strings.NewReader(input))
        split := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
                fmt.Printf("%t\t%d\t%s\n", atEOF, len(data), data)
                return 0, nil, nil
        }
        scanner.Split(split)
        buf := make([]byte, 2)
        scanner.Buffer(buf, bufio.MaxScanTokenSize)
        for scanner.Scan() {
                fmt.Printf("%s\n", scanner.Text())
        }
</code></pre>
<p>输出</p>
<pre><code class="language-go">false   2       ab
false   4       abcd
false   8       abcdefgh
false   12      abcdefghijkl
true    12      abcdefghijkl
</code></pre>
<p>上面的长度是从2开始的，然后是倍数扩增，直到读取完全部的数据，但是扩增的长度还是小于最大的默认长度4096。</p>
<h5 id="error">Error</h5>
<pre><code class="language-go">func (s *Scanner) Err() error
</code></pre>
<p><code>Err</code>返回<code>Scanner</code>遇到的第一个非<code>EOF</code>的错误。</p>
<pre><code class="language-go">func main() {
        // Comma-separated list; last entry is empty.
        const input = "1,2,3,4,"
        scanner := bufio.NewScanner(strings.NewReader(input))
        // Define a split function that separates on commas.
        onComma := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
                for i := 0; i &lt; len(data); i++ {
                        if data == ',' {
                                return i + 1, data[:i], nil
                        }
                }
                if !atEOF {
                        return 0, nil, nil
                }
                // There is one final token to be delivered, which may be the empty string.
                // Returning bufio.ErrFinalToken here tells Scan there are no more tokens after this
                // but does not trigger an error to be returned from Scan itself.
                return 0, data, bufio.ErrFinalToken
        }
        scanner.Split(onComma)
        // Scan.
        for scanner.Scan() {
                fmt.Printf("%q ", scanner.Text())
        }
        if err := scanner.Err(); err != nil {
                fmt.Fprintln(os.Stderr, "reading input:", err)
        }
}
</code></pre>
<p>输出</p>
<pre><code class="language-go">"1" "2" "3" "4" ""
</code></pre>
<h4 id="writer-对象">Writer 对象</h4>
<p>bufio.Write(p []byte) 的思路如下:</p>
<p>1、判断buf中可用容量是否能放下p，如能放下直接存放进去。<br>
2、如果可用容量不能放下，然后判断当前buf是否是空buf。<br>
3、如果是空buf，直接把p写入到文件中。<br>
4、如果buf不为空，使用p把buf填满然后把buf写入到文件中。<br>
5、然后重复1。</p>
<p><img src="https://img2020.cnblogs.com/blog/1237626/202006/1237626-20200624162904412-97660142.png" alt="" loading="lazy"></p>
<pre><code class="language-go">// If nn &lt; len(p), it also returns an error explaining
// why the write is short.
func (b *Writer) Write(p []byte) (nn int, err error) {
        // p的长度大于buf的可用容量
        for len(p) &gt; b.Available() &amp;&amp; b.err == nil {
                var n int
                // buff中内容为空，直接操作p写入到文件中
                if b.Buffered() == 0 {
                        // Large write, empty buffer.
                        // Write directly from p to avoid copy.
                        n, b.err = b.wr.Write(p)
                } else {
            // 如果buff里面内容不是空，使用p填充buff，然后更新buff内容到文件中
                        n = copy(b.buf, p)
                        b.n += n
                        b.Flush()
                }
                nn += n
                p = p
        }
        if b.err != nil {
                return nn, b.err
        }
    // p的长度小于，buff的可用容量，直接存放到buff中即可
        n := copy(b.buf, p)
        b.n += n
        nn += n
        return nn, nil
}
</code></pre>
<h5 id="实例化-1">实例化</h5>
<p>和 <code>Reader</code> 类型一样，<code>bufio</code> 包提供了两个实例化 <code>bufio.Writer</code> 对象的函数：<code>NewWriter</code> 和 <code>NewWriterSize</code>。其中，<code>NewWriter</code> 函数是调用 <code>NewWriterSize</code> 函数实现的：</p>
<pre><code class="language-go">// NewWriter returns a new Writer whose buffer has the default size.
func NewWriter(w io.Writer) *Writer {
    //         defaultBufSize = 4096
        return NewWriterSize(w, defaultBufSize)
}
</code></pre>
<p>NewWriterSize:</p>
<pre><code class="language-go">// NewWriterSize returns a new Writer whose buffer has at least the specified
// size. If the argument io.Writer is already a Writer with large enough
// size, it returns the underlying Writer.
func NewWriterSize(w io.Writer, size int) *Writer {
        // Is it already a Writer?
        b, ok := w.(*Writer)
        if ok &amp;&amp; len(b.buf) &gt;= size {
                return b
        }
        if size &lt;= 0 {
                size = defaultBufSize
        }
        return &amp;Writer{
                buf: make([]byte, size),
                wr:w,
        }
}
</code></pre>
<h5 id="available">Available</h5>
<p>Available 方法获取缓存中还未使用的字节数（缓存大小 - 字段 n 的值）</p>
<h5 id="buffered">Buffered</h5>
<p>Buffered 方法获取写入当前缓存中的字节数（字段 n 的值）</p>
<h5 id="flush">Flush</h5>
<p>该方法将缓存中的所有数据写入底层的 <code>io.Writer</code> 对象中。使用 <code>bufio.Writer</code> 时，在所有的 <code>Write</code> 操作完成之后，应该调用 <code>Flush</code> 方法使得缓存都写入 <code>io.Writer</code> 对象中。</p>
<pre><code class="language-go">// Flush writes any buffered data to the underlying io.Writer.
func (b *Writer) Flush() error {
        if b.err != nil {
                return b.err
        }
        if b.n == 0 {
                return nil
        }
        n, err := b.wr.Write(b.buf)
        if n &lt; b.n &amp;&amp; err == nil {
                err = io.ErrShortWrite
        }
        if err != nil {
                if n &gt; 0 &amp;&amp; n &lt; b.n {
                        copy(b.buf, b.buf)
                }
                b.n -= n
                b.err = err
                return err
        }
        b.n = 0
        return nil
}
</code></pre>
<h5 id="写入的方法">写入的方法</h5>
<pre><code class="language-go">// 实现了 io.ReaderFrom 接口
    func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)

    // 实现了 io.Writer 接口
    func (b *Writer) Write(p []byte) (nn int, err error)

    // 实现了 io.ByteWriter 接口
    func (b *Writer) WriteByte(c byte) error

    // io 中没有该方法的接口，它用于写入单个 Unicode 码点，返回写入的字节数（码点占用的字节），内部实现会根据当前 rune 的范围调用 WriteByte 或 WriteString
    func (b *Writer) WriteRune(r rune) (size int, err error)

    // 写入字符串，如果返回写入的字节数比 len(s) 小，返回的error会解释原因
    func (b *Writer) WriteString(s string) (int, error)
</code></pre>
<p>使用的demo</p>
<pre><code class="language-go">var s = bytes.NewBuffer([]byte{})
        var w = bufio.NewWriter(s)
        w.WriteString("hello world")
        w.WriteString("你好")
        fmt.Printf("string--%s", s.String())
        fmt.Println()
        w.Flush()
        fmt.Printf("string--%s", s.String())
</code></pre>
<p>输出</p>
<pre><code class="language-go">string--
string--hello world你好
</code></pre>
<h5 id="readwriter">ReadWriter</h5>
<p><code>ReadWriter</code> 结构存储了 <code>bufio.Reader</code> 和 <code>bufio.Writer</code> 类型的指针（内嵌），它实现了 <code>io.ReadWriter</code> 结构。</p>
<pre><code class="language-go">    type ReadWriter struct {
      *Reader
      *Writer
    }
</code></pre>
<p><code>ReadWriter</code> 的实例化可以跟普通结构类型一样，也可以通过调用 <code>bufio.NewReadWriter</code> 函数来实现：只是简单的实例化 <code>ReadWriter</code></p>
<pre><code class="language-go">    func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
      return &amp;ReadWriter{r, w}
    }
</code></pre>
<h3 id="总结">总结</h3>
<p><code>bufio</code>中的<code>Writer</code>和<code>Reader</code>实现了带缓存的<code>I/O</code>。其中关于<code>Reader</code>中的操作，都需要一个界定符号，推荐使用<code>ReadBytes</code> or <code>ReadString</code>，不推荐使用<code>ReadLine</code>。ReadSlice 从输入中读取，直到遇到第一个界定符（delim）为止，返回一个指向缓存中字节的 <code>slice</code>，在下次调用读操作（read）时，这些字节会无效，所以我们要慎用，并发读取的时候可能存在问题。在 <code>Reader</code> 类型中，感觉没有让人特别满意的方法。于是，<code>Go1.1</code>增加了一个类型：<code>Scanner</code>。我们一般在读取数据到缓冲区时，且想要采用分隔符分隔数据流时，我们一般使用<code>bufio.Scanner</code>数据结构，而不使用<code>bufio.Reader</code>。但是，需要更多对错误管理的控制或token很大，或必须从<code>reader</code>连续扫描的程序，应使用<code>bufio.Reader</code>代替。对于<code>Writer</code>的使用，我们不要忘记最后的<code>Flush</code>操作。</p><br><br>
来源：https://www.cnblogs.com/ricklz/p/13188188.html

查看完整版本: go中bufio使用小结