如此干货你值得收：Go 语言 bufio 包介绍

最新推荐文章于 2024-10-10 07:15:00 发布
最新推荐文章于 2024-10-10 07:15:00 发布
阅读量757 收藏 3
点赞数 1
分类专栏： GCTT 文章标签： go golang go编程 go语言 gopher
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/polaris1119/article/details/105823753
版权

更多Go语言知识，欢迎关注微信公众号：Go语言中文网

bufio 用来帮助处理 I/O 缓存。 我们将通过一些示例来熟悉其为我们提供的：Reader, Writer and Scanner 等一系列功能

bufio.Writer

多次进行小量的写操作会影响程序性能。每一次写操作最终都会体现为系统层调用，频繁进行该操作将有可能对 CPU 造成伤害。而且很多硬件设备更适合处理块对齐的数据，例如硬盘。为了减少进行多次写操作所需的开支，golang 提供了 bufio.Writer。数据将不再直接写入目的地(实现了 io.Writer 接口)，而是先写入缓存，当缓存写满后再统一写入目的地：

producer --> buffer --> io.Writer

下面具体看一下在9次写入操作中(每次写入一个字符)具有4个字符空间的缓存是如何工作的：

producer        buffer       destination (io.Writer)
   a    ----->    a
   b    ----->    ab
   c    ----->    abc
   d    ----->    abcd
   e    ----->    e      ----->   abcd
   f    ----->    ef
   g    ----->    efg
   h    ----->    efgh
   i    ----->    i      ----->   abcdefgh

-----> 箭头代表写入操作

bufio.Writer 底层使用 []byte 进行缓存

type Writer int
func (*Writer) Write(p []byte) (n int, err error) {
    fmt.Println(len(p))
    return len(p), nil
}
func main() {
    fmt.Println("Unbuffered I/O")
    w := new(Writer)
    w.Write([]byte{'a'})
    w.Write([]byte{'b'})
    w.Write([]byte{'c'})
    w.Write([]byte{'d'})
    fmt.Println("Buffered I/O")
    bw := bufio.NewWriterSize(w, 3)
    bw.Write([]byte{'a'})
    bw.Write([]byte{'b'})
    bw.Write([]byte{'c'})
    bw.Write([]byte{'d'})
    err := bw.Flush()
    if err != nil {
        panic(err)
    }
}
Unbuffered I/O
1
1
1
1
Buffered I/O
3
1

没有被缓存的 I/O：意味着每一次写操作都将直接写入目的地。我们进行4次写操作，每次写操作都映射为对 Write 的调用，调用时传入的参数为一个长度为1的 byte 切片。

使用了缓存的 I/O：我们使用三个字节长度的缓存来存储数据，当缓存满时进行一次 flush 操作(将缓存中的数据进行处理)。前三次写入写满了缓存。第四次写入时检测到缓存没有剩余空间，所以将缓存中的积累的数据写出。字母 d 被存储了，但在此之前 Flush 被调用以腾出空间。当缓存被写到末尾时，缓存中未被处理的数据需要被处理。bufio.Writer 仅在缓存充满或者显式调用 Flush 方法时处理(发送)数据。

bufio.Writer 默认使用 4096 长度字节的缓存，可以使用 NewWriterSize 方法来设定该值

实现

实现十分简单：

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

字段 buf 用来存储数据，当缓存满或者 Flush 被调用时，消费者(wr)可以从缓存中获取到数据。如果写入过程中发生了 I/O error，此 error 将会被赋给 err 字段， error 发生之后，writer 将停止操作(writer is no-op)：

type Writer int
func (*Writer) Write(p []byte) (n int, err error) {
    fmt.Printf("Write: %q\n", p)
    return 0, errors.New("boom!")
}
func main() {
    w := new(Writer)
    bw := bufio.NewWriterSize(w, 3)
    bw.Write([]byte{'a'})
    bw.Write([]byte{'b'})
    bw.Write([]byte{'c'})
    bw.Write([]byte{'d'})
    err := bw.Flush()
    fmt.Println(err)
}
Write: "abc"
boom!

这里我们可以看到 Flush 没有第二次调用消费者的 write 方法。如果发生了 error， 使用了缓存的 writer 不会尝试再次执行写操作。

字段 n 标识缓存内部当前操作的位置。Buffered 方法返回 n 的值：

type Writer int
func (*Writer) Write(p []byte) (n int, err error) {
    return len(p), nil
}
func main() {
    w := new(Writer)
    bw := bufio.NewWriterSize(w, 3)
    fmt.Println(bw.Buffered())
    bw.Write([]byte{'a'})
    fmt.Println(bw.Buffered())
    bw.Write([]byte{'b'})
    fmt.Println(bw.Buffered())
    bw.Write([]byte{'c'})
    fmt.Println(bw.Buffered())
    bw.Write([]byte{'d'})
    fmt.Println(bw.Buffered())
}
0
1
2
3
1

n 从 0 开始，当有数据被添加到缓存中时，该数据的长度值将会被加和到 n中(操作位置向后移动)。当bw.Write([] byte{'d'})被调用时，flush会被触发，n 会被重设为0。

Large writes

type Writer int
func (*Writer) Write(p []byte) (n int, err error) {
    fmt.Printf("%q\n", p)
    return len(p), nil
}
func main() {
    w := new(Writer)
    bw := bufio.NewWriterSize(w, 3)
    bw.Write([]byte("abcd"))
}

由于使用了 bufio，程序打印了 "abcd"。如果 Writer 检测到 Write 方法被调用时传入的数据长度大于缓存的长度(示例中是三个字节)。其将直接调用 writer(目的对象)的 Write 方法。当数据量足够大时，其会自动跳过内部缓存代理。

重置

缓存是 bufio 的核心部分。通过使用 Reset 方法，Writer 可以用于不同的目的对象。重复使用 Writer 缓存减少了内存的分配。而且减少了额外的垃圾回收工作：

type Writer1 int
func (*Writer1) Write(p []byte) (n int, err error) {
    fmt.Printf("writer#1: %q\n", p)
    return len(p), nil
}
type Writer2 int
func (*Writer2) Write(p []byte) (n int, err error) {
    fmt.Printf("writer#2: %q\n", p)
    return len(p), nil
}
func main() {
    w1 := new(Writer1)
    bw := bufio.NewWriterSize(w1, 2)
    bw.Write([]byte("ab"))
    bw.Write([]byte("cd"))
    w2 := new(Writer2)
    bw.Reset(w2)
    bw.Write([]byte("ef"))
    bw.Flush()
}
writer#1: "ab"
writer#2: "ef"

这段代码中有一个 bug。在调用 Reset 方法之前，我们应该使用 Flush flush缓存。 由于 Reset 只是简单的丢弃未被处理的数据，所以已经被写入的数据 cd 丢失了：

func (b *Writer) Reset(w io.Writer) {
    b.err = nil
    b.n = 0
    b.wr = w
}

缓存剩余空间

为了检测缓存中还剩余多少空间, 我们可以使用方法 Available：

w := new(Writer)
bw := bufio.NewWriterSize(w, 2)
fmt.Println(bw.Available())
bw.Write([]byte{'a'})
fmt.Println(bw.Available())
bw.Write([]byte{'b'})
fmt.Println(bw.Available())
bw.Write([]byte{'c'})
fmt.Println(bw.Available())
2
1
0
1

写{Byte,Rune,String}的方法

为了方便, 我们有三个用来写普通类型的实用方法：

w := new(Writer)
bw := bufio.NewWriterSize(w, 10)
fmt.Println(bw.Buffered())
bw.WriteByte('a')
fmt.Println(bw.Buffered())
bw.WriteRune('ł') // 'ł' occupies 2 bytes
fmt.Println(bw.Buffered())
bw.WriteString("aa")
fmt.Println(bw.Buffered())
0
1
3
5

ReadFrom

io 包中定义了 io.ReaderFrom 接口。 该接口通常被 writer 实现，用于从指定的 reader 中读取所有数据(直到 EOF)并对读到的数据进行底层处理：

type ReaderFrom interface {
        ReadFrom(r Reader) (n int64, err error)
}

比如 io.Copy 使用了 io.ReaderFrom 接口

bufio.Writer 实现了此接口：因此我们可以通过调用 ReadFrom 方法来处理从 io.Reader 获取到的所有数据：

type Writer int
func (*Writer) Write(p []byte) (n int, err error) {
    fmt.Printf("%q\n", p)
    return len(p), nil
}
func main() {
    s := strings.NewReader("onetwothree")
    w := new(Writer)
    bw := bufio.NewWriterSize(w, 3)
    bw.ReadFrom(s)
    err := bw.Flush()
    if err != nil {
        panic(err)
    }
}
"one"
"two"
"thr"
"ee"

使用 ReadFrom 方法的同时，调用 Flush 方法也很重要

bufio.Reader

通过它，我们可以从底层的 io.Reader 中更大批量的读取数据。这会使读取操作变少。如果数据读取时的块数量是固定合适的，底层媒体设备将会有更好的表现，也因此会提高程序的性能：

io.Reader --> buffer --> consumer

假设消费者想要从硬盘上读取10个字符(每次读取一个字符)。在底层实现上，这将会触发10次读取操作。如果硬盘按每个数据块四个字节来读取数据，那么 bufio.Reader 将会起到帮助作用。底层引擎将会缓存整个数据块，然后提供一个可以挨个读取字节的 API 给消费者：

abcd -----> abcd -----> a
            abcd -----> b
            abcd -----> c
            abcd -----> d
efgh -----> efgh -----> e
            efgh -----> f
            efgh -----> g
            efgh -----> h
ijkl -----> ijkl -----> i
            ijkl -----> j

-----> 代表读取操作
这个方法仅需要从硬盘读取三次，而不是10次。

Peek

Peek 方法可以帮助我们查看缓存的前 n 个字节而不会真的『吃掉』它：

  • 如果缓存不满，而且缓存中缓存的数据少于 n 个字节，其将会尝试从 io.Reader 中读取
  • 如果请求的数据量大于缓存的容量，将会返回 bufio.ErrBufferFull
  • 如果 n 大于流的大小，将会返回 EOF

让我们来看看它是如何工作的：

s1 := strings.NewReader(strings.Repeat("a", 20))
r := bufio.NewReaderSize(s1, 16)
b, err := r.Peek(3)
if err != nil {
    fmt.Println(err)
}
fmt.Printf("%q\n", b)
b, err = r.Peek(17)
if err != nil {
    fmt.Println(err)
}
s2 := strings.NewReader("aaa")
r.Reset(s2)
b, err = r.Peek(10)
if err != nil {
    fmt.Println(err)
}
"aaa"
bufio: buffer full
EOF

被 bufio.Reader 使用的最小的缓存容器是 16。

返回的切片和被 bufio.Reader 使用的内部缓存底层使用相同的数组。因此引擎底层在执行任何读取操作之后内部返回的切片将会变成无效的。这是由于其将有可能被其他的缓存数据覆盖：

s1 := strings.NewReader(strings.Repeat("a", 16) + strings.Repeat("b", 16))
r := bufio.NewReaderSize(s1, 16)
b, _ := r.Peek(3)
fmt.Printf("%q\n", b)
r.Read(make([]byte, 16))
r.Read(make([]byte, 15))
fmt.Printf("%q\n", b)
"aaa"
"bbb"

Reset

就像 bufio.Writer 那样，缓存也可以用相似的方式被复用。

s1 := strings.NewReader("abcd")
r := bufio.NewReader(s1)
b := make([]byte, 3)
_, err := r.Read(b)
if err != nil {
    panic(err)
}
fmt.Printf("%q\n", b)
s2 := strings.NewReader("efgh")
r.Reset(s2)
_, err = r.Read(b)
if err != nil {
    panic(err)
}
fmt.Printf("%q\n", b)
"abc"
"efg"

通过使用 Reset，我们可以避免冗余的内存分配和不必要的垃圾回收工作。

Discard

这个方法将会丢弃 n 个字节的，返回时也不会返回被丢弃的 n 个字节。如果 bufio.Reader 缓存了超过或者等于 n 个字节的数据。那么其将不必从 io.Reader 中读取任何数据。其只是简单的从缓存中略去前 n 个字节：

type R struct{}
func (r *R) Read(p []byte) (n int, err error) {
    fmt.Println("Read")
    copy(p, "abcdefghijklmnop")
    return 16, nil
}
func main() {
    r := new(R)
    br := bufio.NewReaderSize(r, 16)
    buf := make([]byte, 4)
    br.Read(buf)
    fmt.Printf("%q\n", buf)
    br.Discard(4)
    br.Read(buf)
    fmt.Printf("%q\n", buf)
}
Read
"abcd"
"ijkl"

调用 Discard 方法将不会从 reader r 中读取数据。另一种情况，缓存中数据量小于 n，那么 bufio.Reader 将会读取需要数量的数据来确保被丢弃的数据量不会少于 n：

type R struct{}
func (r *R) Read(p []byte) (n int, err error) {
    fmt.Println("Read")
    copy(p, "abcdefghijklmnop")
    return 16, nil
}
func main() {
    r := new(R)
    br := bufio.NewReaderSize(r, 16)
    buf := make([]byte, 4)
    br.Read(buf)
    fmt.Printf("%q\n", buf)
    br.Discard(13)
    fmt.Println("Discard")
    br.Read(buf)
    fmt.Printf("%q\n", buf)
}
Read
"abcd"
Read
Discard
"bcde"

由于调用了 Discard 方法，所以读取方法被调用了两次。

Read

Read 方法是 bufio.Reader 的核心。它和 io.Reader 的唯一方法具有相同的签名。因此 bufio.Reader 实现了这个普遍存在的接口：

type Reader interface {
        Read(p []byte) (n int, err error)
}

bufio.Reader 的 Read 方法从底层的 io.Reader 中一次读取最大的数量:

  1. 如果内部缓存具有至少一个字节的数据，那么无论传入的切片的大小(len(p))是多少，Read 方法都将仅仅从内部缓存中获取数据，不会从底层的 reader 中读取任何数据:

    func (r *R) Read(p []byte) (n int, err error) {
 fmt.Println("Read")
 copy(p, "abcd")
 return 4, nil
}
func main() {
 r := new(R)
 br := bufio.NewReader(r)
 buf := make([]byte, 2)
 n, err := br.Read(buf)
 if err != nil {
     panic(err)
 }
 buf = make([]byte, 4)
 n, err = br.Read(buf)
 if err != nil {
     panic(err)
 }
 fmt.Printf("read = %q, n = %d\n", buf[:n], n)
}
Read
read = "cd", n = 2

    我们的 io.Reader 实例无线返回「abcd」(不会返回 io.EOF)。 第二次调用 Read并传入长度为4的切片，但是内部缓存在第一次从 io.Reader 中读取数据之后已经具有数据「cd」，所以 bufio.Reader 返回缓存中的数据数据，而不和底层 reader 进行通信。

  2. 如果内部缓存是空的，那么将会执行一次从底层 io.Reader 的读取操作。 从前面的例子中我们可以清晰的看到如果我们开启了一个空的缓存，然后调用:

    n, err := br.Read(buf)

    将会触发读取操作来填充缓存。

  3. 如果内部缓存是空的，但是传入的切片长度大于缓存长度，那么 bufio.Reader 将会跳过缓存，直接读取传入切片长度的数据到切片中:

    type R struct{}
func (r *R) Read(p []byte) (n int, err error) {
 fmt.Println("Read")
 copy(p, strings.Repeat("a", len(p)))
 return len(p), nil
}
func main() {
 r := new(R)
 br := bufio.NewReaderSize(r, 16)
 buf := make([]byte, 17)
 n, err := br.Read(buf)
 if err != nil {
     panic(err)
 }
 fmt.Printf("read = %q, n = %d\n", buf[:n], n)
 fmt.Printf("buffered = %d\n", br.Buffered())
}
Read
read = "aaaaaaaaaaaaaaaaa", n = 17
buffered = 0

    从 bufio.Reader 读取之后，内部缓存中没有任何数据(buffered = 0)

{Read, Unread}Byte

这些方法都实现了从缓存中读取单个字节或者将最后一个读取的字节返回到缓存:

r := strings.NewReader("abcd")
br := bufio.NewReader(r)
byte, err := br.ReadByte()
if err != nil {
    panic(err)
}
fmt.Printf("%q\n", byte)
fmt.Printf("buffered = %d\n", br.Buffered())
err = br.UnreadByte()
if err != nil {
    panic(err)
}
fmt.Printf("buffered = %d\n", br.Buffered())
byte, err = br.ReadByte()
if err != nil {
    panic(err)
}
fmt.Printf("%q\n", byte)
fmt.Printf("buffered = %d\n", br.Buffered())
'a'
buffered = 3
buffered = 4
'a'
buffered = 3

{Read, Unread}Rune

这两个方法的功能和前面方法的功能差不多, 但是用来处理 Unicode 字符(UTF-8 encoded)。

ReadSlice

函数返回在第一次出现传入字节前的字节:

func (b *Reader) ReadSlice(delim byte) (line []byte, err error)

示例:

s := strings.NewReader("abcdef|ghij")
r := bufio.NewReader(s)
token, err := r.ReadSlice('|')
if err != nil {
    panic(err)
}
fmt.Printf("Token: %q\n", token)
Token: "abcdef|"

重要：返回的切面指向内部缓冲区, 因此它可能在下一次读取操作期间被覆盖

如果找不到分隔符，而且已经读到末尾(EOF)，将会返回 io.EOF error。 让我们将上面程序中的一行修改为如下代码:

s := strings.NewReader("abcdefghij")

如果数据以 panic: EOF 结尾。 当分隔符找不到而且没有更多的数据可以放入缓冲区时函数将返回 io.ErrBufferFull:

s := strings.NewReader(strings.Repeat("a", 16) + "|")
r := bufio.NewReaderSize(s, 16)
token, err := r.ReadSlice('|')
if err != nil {
    panic(err)
}
fmt.Printf("Token: %q\n", token)

这一小段代码会出现错误:panic: bufio: buffer full。

ReadBytes

func (b *Reader) ReadBytes(delim byte) ([]byte, error)

返回出现第一次分隔符前的所有数据组成的字节切片。 它和 ReadSlice 具有相同的签名，但是 ReadSlice 是一个低级别的函数，ReadBytes 的实现使用了 ReadSlice。 那么两者之间有什么不同呢? 在分隔符找不到的情况下，ReadBytes 可以多次调用 ReadSlice，而且可以累积返回的数据。 这意味着 ReadBytes 将不再受到 缓存大小的限制:

s := strings.NewReader(strings.Repeat("a", 40) + "|")
r := bufio.NewReaderSize(s, 16)
token, err := r.ReadBytes('|')
if err != nil {
    panic(err)
}
fmt.Printf("Token: %q\n", token)
Token: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa|"

另外该函数返回一个新的字节切片，所以没有数据会被将来的读取操作覆盖的风险。

ReadString

它是我们上面讨论的 ReadBytes 的简单封装:

func (b *Reader) ReadString(delim byte) (string, error) {
    bytes, err := b.ReadBytes(delim)
    return string(bytes), err
}

ReadLine

ReadLine() (line []byte, isPrefix bool, err error)

内部使用 ReadSlice (ReadSlice('\n'))实现，同时从返回的切片中移除掉换行符(\n 或者 \r\n)。 此方法的签名不同于 ReadBytes 或者 ReadSlice，因为它包含 isPrefix 标志。 由于内部缓存无法存储更多的数据，当找不到分隔符时该标志为 true:

s := strings.NewReader(strings.Repeat("a", 20) + "\n" + "b")
r := bufio.NewReaderSize(s, 16)
token, isPrefix, err := r.ReadLine()
if err != nil {
    panic(err)
}
fmt.Printf("Token: %q, prefix: %t\n", token, isPrefix)
token, isPrefix, err = r.ReadLine()
if err != nil {
    panic(err)
}
fmt.Printf("Token: %q, prefix: %t\n", token, isPrefix)
token, isPrefix, err = r.ReadLine()
if err != nil {
    panic(err)
}
fmt.Printf("Token: %q, prefix: %t\n", token, isPrefix)
token, isPrefix, err = r.ReadLine()
if err != nil {
    panic(err)
}
Token: "aaaaaaaaaaaaaaaa", prefix: true
Token: "aaaa", prefix: false
Token: "b", prefix: false
panic: EOF

如果最后一次返回的切片以换行符结尾，此方法将不会给出任何信息:

s := strings.NewReader("abc")
r := bufio.NewReaderSize(s, 16)
token, isPrefix, err := r.ReadLine()
if err != nil {
    panic(err)
}
fmt.Printf("Token: %q, prefix: %t\n", token, isPrefix)
s = strings.NewReader("abc\n")
r.Reset(s)
token, isPrefix, err = r.ReadLine()
if err != nil {
    panic(err)
}
fmt.Printf("Token: %q, prefix: %t\n", token, isPrefix)
Token: "abc", prefix: false
Token: "abc", prefix: false

WriteTo

bufio.Reader 实现了 io.WriterTo 接口:

type WriterTo interface {
        WriteTo(w Writer) (n int64, err error)
}

此方法允许我们传入一个实现了 io.Writer 的消费者。 从生产者读取的所有数据都将会被送到消费者。 下面通过练习来看看它是如何工作的:

type R struct {
    n int
}
func (r *R) Read(p []byte) (n int, err error) {
    fmt.Printf("Read #%d\n", r.n)
    if r.n >= 10 {
         return 0, io.EOF
    }
    copy(p, "abcd")
    r.n += 1
    return 4, nil
}
func main() {
    r := bufio.NewReaderSize(new(R), 16)
    n, err := r.WriteTo(ioutil.Discard)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Written bytes: %d\n", n)
}
Read #0
Read #1
Read #2
Read #3
Read #4
Read #5
Read #6
Read #7
Read #8
Read #9
Read #10
Written bytes: 40

bufio.Scanner

go语言中对bufio.Scanner的深层分析

ReadBytes(’\n’), ReadString(’\n’), ReadLine 还是 Scanner?

就像前面说的那样，ReadString('\n') 只是对于 ReadBytes(\n) 的简单封装。 所以让我们来讨论一下另外三者之间的不同之处吧。

  1. ReadBytes 不会自动处理 \r\n 序列:

    s := strings.NewReader("a\r\nb")
r := bufio.NewReader(s)
for {
 token, _, err := r.ReadLine()
 if len(token) > 0 {
     fmt.Printf("Token (ReadLine): %q\n", token)
 }
 if err != nil {
     break
 }
}
s.Seek(0, io.SeekStart)
r.Reset(s)
for {
 token, err := r.ReadBytes('\n')
 fmt.Printf("Token (ReadBytes): %q\n", token)
 if err != nil {
     break
 }
}
s.Seek(0, io.SeekStart)
scanner := bufio.NewScanner(s)
for scanner.Scan() {
 fmt.Printf("Token (Scanner): %q\n", scanner.Text())
}
Token (ReadLine): "a"
Token (ReadLine): "b"
Token (ReadBytes): "a\r\n"
Token (ReadBytes): "b"
Token (Scanner): "a"
Token (Scanner): "b"

    ReadBytes 会将分隔符一起返回，所以需要额外的一些工作来重新处理数据(除非返回分隔符是有用的)。

  2. ReadLine 不会处理超出内部缓存的行:

    s := strings.NewReader(strings.Repeat("a", 20) + "\n")
r := bufio.NewReaderSize(s, 16)
token, _, _ := r.ReadLine()
fmt.Printf("Token (ReadLine): \t%q\n", token)
s.Seek(0, io.SeekStart)
r.Reset(s)
token, _ = r.ReadBytes('\n')
fmt.Printf("Token (ReadBytes): \t%q\n", token)
s.Seek(0, io.SeekStart)
scanner := bufio.NewScanner(s)
scanner.Scan()
fmt.Printf("Token (Scanner): \t%q\n", scanner.Text())
Token (ReadLine):     "aaaaaaaaaaaaaaaa"
Token (ReadBytes):     "aaaaaaaaaaaaaaaaaaaa\n"
Token (Scanner):     "aaaaaaaaaaaaaaaaaaaa"

    为了取回流中剩余的数据，ReadLine 需要被调用两次。 被 Scanner 处理的最大 token 长度为 641024。 如果传入更长的 token，scanner 将无法工作。 当 ReadLine 被多次调用时可以处理任何长度的 token。 由于函数返回是否在缓存数据中找到分隔符的标志，但是这需要调用者进行处理。 ReadBytes* 则没有任何限制:

    s := strings.NewReader(strings.Repeat("a", 64*1024) + "\n")
r := bufio.NewReader(s)
token, _, err := r.ReadLine()
fmt.Printf("Token (ReadLine): %d\n", len(token))
fmt.Printf("Error (ReadLine): %v\n", err)
s.Seek(0, io.SeekStart)
r.Reset(s)
token, err = r.ReadBytes('\n')
fmt.Printf("Token (ReadBytes): %d\n", len(token))
fmt.Printf("Error (ReadBytes): %v\n", err)
s.Seek(0, io.SeekStart)
scanner := bufio.NewScanner(s)
scanner.Scan()
fmt.Printf("Token (Scanner): %d\n", len(scanner.Text()))
fmt.Printf("Error (Scanner): %v\n", scanner.Err())
Token (ReadLine): 4096
Error (ReadLine): <nil>
Token (ReadBytes): 65537
Error (ReadBytes): <nil>
Token (Scanner): 0
Error (Scanner): bufio.Scanner: token too long

  3. 就像上面那样，Scanner 具有非常简单的 API，对于普通的例子，它还提供了友好的抽象概念。

bufio.ReadWriter

Go 的结构体中可以使用一种叫做内嵌的类型。 和常规的具有类型和名字的字段不同，我们可以仅仅使用类型(匿名字段)。 内嵌类型的方法或者字段如果不和其他的冲突的话，则可以使用一个简短的选择器来引用:

type T1 struct {
    t1 string
}
func (t *T1) f1() {
    fmt.Println("T1.f1")
}
type T2 struct {
    t2 string
}
func (t *T2) f2() {
    fmt.Println("T1.f2")
}
type U struct {
    *T1
    *T2
}
func main() {
    u := U{T1: &T1{"foo"}, T2: &T2{"bar"}}
    u.f1()
    u.f2()
    fmt.Println(u.t1)
    fmt.Println(u.t2)
}
T1.f1
T1.f2
foo
bar

我们可以简单的使用 u.t1 来代替 u.T1.t1。 包 bufio 使用内嵌的方式来定义 ReadWriter。 它由 Reader 和 Writer 构成:

type ReadWriter struct {
      *Reader
      *Writer
  }

让我们来看看它是如何使用的:

s := strings.NewReader("abcd")
br := bufio.NewReader(s)
w := new(bytes.Buffer)
bw := bufio.NewWriter(w)
rw := bufio.NewReadWriter(br, bw)
buf := make([]byte, 2)
_, err := rw.Read(buf)
if err != nil {
    panic(err)
}
fmt.Printf("%q\n", buf)
buf = []byte("efgh")
_, err = rw.Write(buf)
if err != nil {
    panic(err)
}
err = rw.Flush()
if err != nil {
   panic(err)
}
fmt.Println(w.String())
"ab"
efgh

由于 reader 和 writer 都具有方法 Buffered，所以若想获取缓存数据的量，rw.Buffered() 将无法工作，编译器会报错：ambiguous selector rw.Buffered。 但是类似 rw.Reader.Buffered() 的方式是可以的。

bufio + standard library

bufio 包被广泛使用在 I/O出现的标准库中，例如:

  • archive/zip
  • compress/*
  • encoding/*
  • image/*
  • 类似于 net/http 的TCP连接包装。 它还结合一些类似于 sync.Pool 的缓存框架来减少垃圾回收的压力

via: https://medium.com/golangspec/introduction-to-bufio-package-in-golang-ad7d1877f762

作者：Michał Łowicki 译者：jliu666 校对：rxcai

本文由 GCTT 原创编译，Go语言中文网 荣誉推出

更多Go语言知识，欢迎关注微信公众号：Go语言中文网

polaris1119
关注
专栏目录
Go 编程必备：bufio 库的全面指南与实战技巧
walkskyer的博客
01-04 2148
在这篇文章中，我们全面探索了 Go 语言的bufio库，包括它的主要组件和的使用方法和应用场景。bufio库作为 Go 标准库中的重要组成部分，其在提高数据处理效率和性能方面的作用不可忽视。
Golang bufio包源码分析
skh2015java的博客
08-08 593
go 源码1.10.3 bufio.go 一、bufio介绍 bufio实现了带缓冲的IO功能，它是在io.Reader和io.Writer接口对象上提供了进一步的封装，从而提供了更加丰富的操作方法。bufio包主要 二、bufio.Reader 1.结构体 type Reader struct { buf []byte //缓冲区的数据 rd io.Reader // 底层的io.Reader r, w int ...
Golang 中的 bufio 包详解（四）：bufio.Scanner
路多辛的所思所想
06-24 1782
bufio.Scanner 是 Golang 中一个用于逐个读取输入缓冲区的扫描器，通常与 bufio.Reader 一起使用，bufio.Reader 用于从输入中读取数据，而 bufio.Scanner 则用于逐个读取输入缓冲区的内容。bufio.Scanner 可以将输入数据分解为逻辑上的行并返回。Scanner 通过定义一个 Split 函数来将输入分解为行。
【Golang】Go语言中缓冲bufio的原理解读与应用实战
最新发布
景天科技苑
10-10 2万+
bufio是Go语言标准库中的一个重要包，它提供了带缓冲的I/O操作，用于包装io.Reader或io.Writer对象，以减少I/O操作的次数，从而提高读写性能。本文将结合实际案例，详细讲解bufio在Go语言中的用法。 Go语言自带的IO操作包。bufio，使用这个包可以大幅提升文件的读写效率。 buf： 缓冲区. io操作效率本身是还可以的，频繁访问本地磁盘文件（效率低） 所以说 bufio ，提供了一个缓冲区，读和写都先在缓冲区中，最后再一次性读取或者写入到文件里，降低访问本地磁盘的次数。
golang 中bufio包的用法
weixin_34275734的博客
10-20 620
本文转自GOlove博客：http://www.cnblogs.com/golove/p/3282667.html 并在此基础上进行了一些添加修改． bufio 包中的函数和方法 // bufio 包实现了带缓存的 I/O 操作 // 它封装一个 io.Reader 或 io.Writer 对象 // 使其具有缓存和一些文本读写功能 ------...
Golang 中的 bufio 包详解（五）：常用函数
路多辛的所思所想
06-25 841
Golang 中的 bufio 包是带缓冲 I/O 操作的标准库，之前的几篇文章详细讲解了 bufio.Reader、bufio.Writer 和 bufio.Scanner 这个几个结构体的使用方法、特性和使用场景，本文介绍一下 bufio 包中的函数。ReadWriter 结构体实现了 io.ReadWriter 接口，SplitFunc 是用来指定自定义分割规则的函数类型，通常结合 bufio.Scanner 使用。
Go：标准库bufio包详解
十年运维开发经验的王义杰在此分享自己的知识和经验
05-04 590
bufio包主要提供了缓冲读写的能力，通过包装一个io.Reader或io.Writer对象，创建一个带缓冲的（buffered）读写器。使用缓冲可以减少对底层IO资源的直接操作次数，这通常能显著提高IO操作的效率，尤其是在进行大量的小型读写操作时更为明显。在Go语言中，bufio包是处理文件及网络IO操作的利器。了解并合理使用这个包，对于编写高效且可靠的IO操作代码至关重要。
干货：有关MEMS的详细介绍
01-19
虽然大部分人对于MEMS（Microelectromechanical systems， 微机电系统/微机械/微系统）还是感到很陌生，但是其实MEMS在我们生产，甚至生活中早已无处不在了，智能手机，健身手环、打印机、汽车、无人机以及VR/AR头戴...
干货3分钟掌握：简单好用的UML类图绘画方法
01-05
干货3分钟掌握：简单好用的UML类图绘画方法干货3分钟掌握：简单好用的UML类图绘画方法干货3分钟掌握：简单好用的UML类图绘画方法干货3分钟掌握：简单好用的UML类图绘画方法v干货3分钟掌握：简单好用的UML类图绘画...
干货：用Python进行数据清洗，这7种方法你一定要掌握
01-27
数据录入过程、数据整合过程都可能会产生重复数据，直接删除是重复数据处理的主要方法。pandas提供查看、处理重复数据的方法duplicated和drop_duplicates。以如下数据为例: 发现重复数据通过duplicated方法完成，...
Go语言笔记.nyf（教程笔记）
10-24
B站《【整整500集】清华大佬196小时讲完的Go语言教程（golang进阶实战）全程干货无废话》教程笔记
微信小程序学习用demo：干货集中营；收藏，表单使用
03-15
收藏功能：   其他的一些功能展示：   免责声明：本站所有文章和图片均来自用户分享和网络收集，文章和图片版权归原作者及原出处所有，仅供学习与参考，请勿用于商业用途，如果损害了您的权利，请联系网站客服...
Go源码学习：bufio包 - 1.1 - bufio.go -（1）
风不归的乐园
12-24 1173
Go：bufio：bufio包的作用、目的和基本结构、Size、Reset、fill、Peek、Discard
golang package bufio
Geek猫的专栏
01-15 309
bufio包实现了有缓冲的I/O。它包装一个io.Reader或io.Writer接口对象，创建另一个也实现了该接口，且同时还提供了缓冲和一些文本I/O的帮助函数的对象。 func NewReader(rd io.Reader) *Reader NewReader创建一个具有默认大小缓冲、从r读取的*Reader。 ...
GO语言基础进阶教程：bufio包
qfzhangxu的博客
07-14 352
生命不止，继续Go go go。。 Go语言在io操作中，还提供了一个bufio的包，使用这个包可以大幅提高文件读写的效率。 一、bufio包原理 bufio 是通过缓冲来提高效率。 io操作本身的效率并不低，低的是频繁的访问本地磁盘的文件。所以bufio就提供了缓冲区(分配一块内存)，读和写都先在缓冲区中，最后再读写文件，来降低访问本地磁盘的次数，从而提高效率。 简单的说就是，把文件读取进缓冲（内存）之后再读取的时候就可以避免文件系统的io 从而提高速度。同理，在进行写操作时，先把文件写入缓冲（
bufio详解
manclient的博客
01-21 3786
bufio包实现了有缓冲的I/O,它封装了一个io.Reader或io.Write接口对象，创建一个实现实现了该接口，同时提供缓冲和一些文本I/O的帮助函数. type Reader struct { buf []byte rd io.Reader // reader provided by the client r, w int // buf read and write positions
bufio
xiaoxiaoyu85的专栏
10-16 113
import "bufio" rd := bufio.NewReader(f) for { //strLine, err := rd.ReadString('\n') //以'\n'为结束符读入一行 byteLine, _, err := rd.ReadLine() //以'\n'为结束符读入一行 strLine := string(byteLi...
golang-bufio 缓冲读
qq_40734247的博客
08-29 783
好了，到这里就结束了。这里至少Reader相关的部分，后面还会继续Writer相关的部分。不过，目前还没有特别好的记录方式，只是大致挑几个代码贴出来，写一些自己的理解，然后配一些示意图，再加上一些测试代码。这篇博客不是为了说明这个包是怎么使用的，而是为什么要用它，以及它的一些实现的细节。现这样写吧，以后再探索是不是有更好的方式。
Go标准库学习笔记-带缓冲的IO（bufio）
preyta的专栏
06-11 9599
概述 bufio模块通过对io模块的封装，提供了数据缓冲功能，能够一定程度减少大块数据读写带来的开销。 实际上在bufio各个组件内部都维护了一个缓冲区，数据读写操作都直接通过缓存区进行。当发起一次读写操作时，会首先尝试从缓冲区获取数据；只有当缓冲区没有数据时，才会从数据源获取数据更新缓冲。 Reader 可以通过NewReader函数创建bufio.Reader对象，函数接收一个io...
2018年后干货运输衰退预测：下一个海啸何时来临？
本文是一篇深入的行业研究，标题为《预测2018年后的下一个干货运输萧条》。作者Alexandros M. Goulielmos，来自希腊的Piraeus大学和雅典的Athens商学院，专注于海运领域的研究。研究的焦点在于利用非线性预测方法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值