Golang之bytes.buffer

bytes.buffer是一个缓冲byte类型的缓冲器存放着都是byte

Buffer 是 bytes 包中的一个 type Buffer struct{…}

A buffer is a variable-sized buffer of bytes with Read and Write methods. The zero value for Buffer is an empty buffer ready to use.

（是一个变长的 buffer，具有 Read 和Write 方法。 Buffer 的 零值 是一个 空的 buffer，但是可以使用）

Buffer 就像一个集装箱容器，可以存东西，取东西（存取数据）

  • 创建 一个 Buffer （其实底层就是一个 []byte， 字节切片）
  • 向其中写入数据 (Write mtheods)
  • 从其中读取数据 (Write methods)

创建 Buffer缓冲器

var b bytes.Buffer  //直接定义一个 Buffer 变量，而不用初始化
b.Writer([]byte("Hello ")) // 可以直接使用

b1 := new(bytes.Buffer)   //直接使用 new 初始化，可以直接使用
// 其它两种定义方式
func NewBuffer(buf []byte) *Buffer
func NewBufferString(s string) *Buffer

NewBuffer

// NewBuffer creates and initializes a new Buffer using buf as its initial
// contents.  It is intended to prepare a Buffer to read existing data.  It
// can also be used to size the internal buffer for writing. To do that,
// buf should have the desired capacity but a length of zero.
//
// In most cases, new(Buffer) (or just declaring a Buffer variable) is
// sufficient to initialize a Buffer.
func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }
  • NewBuffer使用buf作为参数初始化Buffer，
  • Buffer既可以被读也可以被写
  • 如果是读Buffer，buf需填充一定的数据
  • 如果是写，buf需有一定的容量(capacity)，当然也可以通过new(Buffer)来初始化Buffer。另外一个方法NewBufferString用一个string来初始化可读Buffer，并用string的内容填充Buffer.
func IntToBytes(n int) []byte {
    x := int32(n)
    //创建一个内容是[]byte的slice的缓冲器
    //与bytes.NewBufferString("")等效
    bytesBuffer := bytes.NewBuffer([]byte{})
    binary.Write(bytesBuffer, binary.BigEndian, x)
    return bytesBuffer.Bytes()
}

NewBufferString

  • 方法NewBufferString用一个string来初始化可读Buffer，并用string的内容填充Buffer.
  • 用法和NewBuffer没有太大区别
// NewBufferString creates and initializes a new Buffer using string s as its
// initial contents. It is intended to prepare a buffer to read an existing
// string.
//
// In most cases, new(Buffer) (or just declaring a Buffer variable) is
// sufficient to initialize a Buffer.
func NewBufferString(s string) *Buffer {
    return &Buffer{buf: []byte(s)}
}

func TestBufferString(){
    buf1:=bytes.NewBufferString("swift")
    buf2:=bytes.NewBuffer([]byte("swift"))
    buf3:=bytes.NewBuffer([]byte{‘s‘,‘w‘,‘i‘,‘f‘,‘t‘})
    fmt.Println("===========以下buf1,buf2,buf3等效=========")
    fmt.Println("buf1:", buf1)
    fmt.Println("buf2:", buf2)
    fmt.Println("buf3:", buf3)
    fmt.Println("===========以下创建空的缓冲器等效=========")
    buf4:=bytes.NewBufferString("")
    buf5:=bytes.NewBuffer([]byte{})
    fmt.Println("buf4:", buf4)
    fmt.Println("buf5:", buf5)
}

输出：

===========以下buf1,buf2,buf3等效=========

buf1: swift

buf2: swift

buf3: swift

===========以下创建空的缓冲器等效=========

buf4:

buf5:

向 Buffer 中写入数据

Write

把字节切片 p 写入到buffer中去。

// Write appends the contents of p to the buffer, growing the buffer as
// needed. The return value n is the length of p; err is always nil. If the
// buffer becomes too large, Write will panic with ErrTooLarge.
func (b *Buffer) Write(p []byte) (n int, err error) {
    b.lastRead = opInvalid
    m := b.grow(len(p))
    return copy(b.buf[m:], p), nil
}
fmt.Println("===========以下通过Write把swift写入Learning缓冲器尾部=========")
    newBytes := []byte("swift")
    //创建一个内容Learning的缓冲器
    buf := bytes.NewBuffer([]byte("Learning"))
    //打印为Learning
    fmt.Println(buf.String())
    //将newBytes这个slice写到buf的尾部
    buf.Write(newBytes)
    fmt.Println(buf.String())

打印：

===========以下通过Write把swift写入Learning缓冲器尾部=========

Learning

Learningswift

WriteString

使用WriteString方法，将一个字符串放到缓冲器的尾部

// WriteString appends the contents of s to the buffer, growing the buffer as
// needed. The return value n is the length of s; err is always nil. If the
// buffer becomes too large, WriteString will panic with ErrTooLarge.
func (b *Buffer) WriteString(s string) (n int, err error) {
    b.lastRead = opInvalid
    m := b.grow(len(s))
    return copy(b.buf[m:], s), nil
}
    fmt.Println("===========以下通过WriteString把swift写入Learning缓冲器尾部=========")
    newString := "swift"
    //创建一个string内容Learning的缓冲器
    buf := bytes.NewBufferString("Learning")
    //打印为Learning
    fmt.Println(buf.String())
    //将newString这个string写到buf的尾部
    buf.WriteString(newString)
    fmt.Println(buf.String())

打印：

===========以下通过Write把swift写入Learning缓冲器尾部=========

Learning

Learningswift

WriteByte

将一个byte类型的数据放到缓冲器的尾部

// WriteByte appends the byte c to the buffer, growing the buffer as needed.
// The returned error is always nil, but is included to match bufio.Writer‘s
// WriteByte. If the buffer becomes too large, WriteByte will panic with
// ErrTooLarge.
func (b *Buffer) WriteByte(c byte) error {
    b.lastRead = opInvalid
    m := b.grow(1)
    b.buf[m] = c
    return nil
}
fmt.Println("===========以下通过WriteByte把!写入Learning缓冲器尾部=========")
    var newByte byte = ‘!‘
    //创建一个string内容Learning的缓冲器
    buf := bytes.NewBufferString("Learning")
    //打印为Learning
    fmt.Println(buf.String())
    //将newString这个string写到buf的尾部
    buf.WriteByte(newByte)
    fmt.Println(buf.String())

打印：

===========以下通过WriteByte把swift写入Learning缓冲器尾部=========

Learning

Learning!

WriteRune

将一个rune类型的数据放到缓冲器的尾部

// WriteRune appends the UTF-8 encoding of Unicode code point r to the
// buffer, returning its length and an error, which is always nil but is
// included to match bufio.Writer‘s WriteRune. The buffer is grown as needed;
// if it becomes too large, WriteRune will panic with ErrTooLarge.
func (b *Buffer) WriteRune(r rune) (n int, err error) {
    if r < utf8.RuneSelf {
        b.WriteByte(byte(r))
        return 1, nil
    }
    n = utf8.EncodeRune(b.runeBytes[0:], r)
    b.Write(b.runeBytes[0:n])
    return n, nil
}
    fmt.Println("===========以下通过WriteRune把\"好\"写入Learning缓冲器尾部=========")
    var newRune = ‘好‘
    //创建一个string内容Learning的缓冲器
    buf := bytes.NewBufferString("Learning")
    //打印为Learning
    fmt.Println(buf.String())
    //将newString这个string写到buf的尾部
    buf.WriteRune(newRune)
    fmt.Println(buf.String())

打印：

===========以下通过WriteRune把”好”写入Learning缓冲器尾部=========

Learning

Learning好

完整示例

package main

import (
    "bytes"
    "encoding/binary"
    "fmt"
)

func main() {
    //newBuffer 整形转换成字节
    var n int = 10000
    intToBytes := IntToBytes(n)
    fmt.Println("==========int to bytes========")
    fmt.Println(intToBytes)
    //NewBufferString
    TestBufferString()
    //write
    BufferWrite()
    //WriteString
    BufferWriteString()
    //WriteByte
    BufferWriteByte()
    //WriteRune
    BufferWriteRune()

}

func IntToBytes(n int) []byte {
    x := int32(n)
    //创建一个内容是[]byte的slice的缓冲器
    //与bytes.NewBufferString("")等效
    bytesBuffer := bytes.NewBuffer([]byte{})
    binary.Write(bytesBuffer, binary.BigEndian, x)
    return bytesBuffer.Bytes()
}

func TestBufferString(){
    buf1:=bytes.NewBufferString("swift")
    buf2:=bytes.NewBuffer([]byte("swift"))
    buf3:=bytes.NewBuffer([]byte{‘s‘,‘w‘,‘i‘,‘f‘,‘t‘})
    fmt.Println("===========以下buf1,buf2,buf3等效=========")
    fmt.Println("buf1:", buf1)
    fmt.Println("buf2:", buf2)
    fmt.Println("buf3:", buf3)
    fmt.Println("===========以下创建空的缓冲器等效=========")
    buf4:=bytes.NewBufferString("")
    buf5:=bytes.NewBuffer([]byte{})
    fmt.Println("buf4:", buf4)
    fmt.Println("buf5:", buf5)
}

func BufferWrite(){
    fmt.Println("===========以下通过Write把swift写入Learning缓冲器尾部=========")
    newBytes := []byte("swift")
    //创建一个内容Learning的缓冲器
    buf := bytes.NewBuffer([]byte("Learning"))
    //打印为Learning
    fmt.Println(buf.String())
    //将newBytes这个slice写到buf的尾部
    buf.Write(newBytes)
    fmt.Println(buf.String())
}

func BufferWriteString(){
    fmt.Println("===========以下通过Write把swift写入Learning缓冲器尾部=========")
    newString := "swift"
    //创建一个string内容Learning的缓冲器
    buf := bytes.NewBufferString("Learning")
    //打印为Learning
    fmt.Println(buf.String())
    //将newString这个string写到buf的尾部
    buf.WriteString(newString)
    fmt.Println(buf.String())
}

func BufferWriteByte(){
    fmt.Println("===========以下通过WriteByte把swift写入Learning缓冲器尾部=========")
    var newByte byte = ‘!‘
    //创建一个string内容Learning的缓冲器
    buf := bytes.NewBufferString("Learning")
    //打印为Learning
    fmt.Println(buf.String())
    //将newString这个string写到buf的尾部
    buf.WriteByte(newByte)
    fmt.Println(buf.String())
}

func BufferWriteRune(){
    fmt.Println("===========以下通过WriteRune把\"好\"写入Learning缓冲器尾部=========")
    var newRune = ‘好‘
    //创建一个string内容Learning的缓冲器
    buf := bytes.NewBufferString("Learning")
    //打印为Learning
    fmt.Println(buf.String())
    //将newString这个string写到buf的尾部
    buf.WriteRune(newRune)
    fmt.Println(buf.String())
}

向 Buffer 中读取数据

Read

给Read方法一个容器p，读完后，p就满了，缓冲器相应的减少了，返回的n为成功读的数量

// Read reads the next len(p) bytes from the buffer or until the buffer
// is drained.  The return value n is the number of bytes read.  If the
// buffer has no data to return, err is io.EOF (unless len(p) is zero);
// otherwise it is nil.
func (b *Buffer) Read(p []byte) (n int, err error) {}
func Read(){
    bufs := bytes.NewBufferString("Learning swift.")
    fmt.Println(bufs.String())

    //声明一个空的slice,容量为8
    l := make([]byte, 8)
    //把bufs的内容读入到l内,因为l容量为8,所以只读了8个过来
    bufs.Read(l)
    fmt.Println("::bufs缓冲器内容::")
    fmt.Println(bufs.String())
    //空的l被写入了8个字符,所以为 Learning
    fmt.Println("::l的slice内容::")
    fmt.Println(string(l))
    //把bufs的内容读入到l内,原来的l的内容被覆盖了
    bufs.Read(l)
    fmt.Println("::bufs缓冲器被第二次读取后剩余的内容::")
    fmt.Println(bufs.String())
    fmt.Println("::l的slice内容被覆盖,由于bufs只有7个了,因此最后一个g被留下来了::")
    fmt.Println(string(l))

}

打印：

=======Read=======

Learning swift.

::bufs缓冲器内容::

swift.

::l的slice内容::

Learning

::bufs缓冲器被第二次读取后剩余的内容::

::l的slice内容被覆盖::

swift.g

ReadByte

返回缓冲器头部的第一个byte，缓冲器头部第一个byte被拿掉

// ReadByte reads and returns the next byte from the buffer.
// If no byte is available, it returns error io.EOF.
func (b *Buffer) ReadByte() (c byte, err error) {}
func ReadByte(){
    bufs := bytes.NewBufferString("Learning swift.")
    fmt.Println(bufs.String())
    //读取第一个byte,赋值给b
    b, _ := bufs.ReadByte()
    fmt.Println(bufs.String())
    fmt.Println(string(b))
}

打印：

=======ReadByte===

Learning swift.

earning swift.

L

ReadRune

ReadRune和ReadByte很像

返回缓冲器头部的第一个rune，缓冲器头部第一个rune被拿掉

// ReadRune reads and returns the next UTF-8-encoded
// Unicode code point from the buffer.
// If no bytes are available, the error returned is io.EOF.
// If the bytes are an erroneous UTF-8 encoding, it
// consumes one byte and returns U+FFFD, 1.
func (b *Buffer) ReadRune() (r rune, size int, err error) {}
func ReadRune(){
    bufs := bytes.NewBufferString("学swift.")
    fmt.Println(bufs.String())

    //读取第一个rune,赋值给r
    r,z,_ := bufs.ReadRune()
    //打印中文"学",缓冲器头部第一个被拿走
    fmt.Println(bufs.String())
    //打印"学","学"作为utf8储存占3个byte
    fmt.Println("r=",string(r),",z=",z)

}

ReadBytes

ReadBytes需要一个byte作为分隔符，读的时候从缓冲器里找第一个出现的分隔符（delim），找到后，把从缓冲器头部开始到分隔符之间的所有byte进行返回，作为byte类型的slice，返回后，缓冲器也会空掉一部分

// ReadBytes reads until the first occurrence of delim in the input,
// returning a slice containing the data up to and including the delimiter.
// If ReadBytes encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often io.EOF).
// ReadBytes returns err != nil if and only if the returned data does not end in
// delim.
func (b *Buffer) ReadBytes(delim byte) (line []byte, err error) {}
func ReadBytes(){
    bufs := bytes.NewBufferString("现在开始 Learning swift.")
    fmt.Println(bufs.String())

    var delim byte = ‘L‘
    line, _ := bufs.ReadBytes(delim)
    fmt.Println(bufs.String())
    fmt.Println(string(line))
}

打印：

=======ReadBytes==

现在开始 Learning swift.

earning swift.

现在开始 L

ReadString

ReadString需要一个byte作为分隔符，读的时候从缓冲器里找第一个出现的分隔符（delim），找到后，把从缓冲器头部开始到分隔符之间的所有byte进行返回，作为字符串，返回后，缓冲器也会空掉一部分

和ReadBytes类似

// ReadString reads until the first occurrence of delim in the input,
// returning a string containing the data up to and including the delimiter.
// If ReadString encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often io.EOF).
// ReadString returns err != nil if and only if the returned data does not end
// in delim.
func (b *Buffer) ReadString(delim byte) (line string, err error) {}

ReadFrom

从一个实现io.Reader接口的r，把r里的内容读到缓冲器里，n返回读的数量

// ReadFrom reads data from r until EOF and appends it to the buffer, growing
// the buffer as needed. The return value n is the number of bytes read. Any
// error except io.EOF encountered during the read is also returned. If the
// buffer becomes too large, ReadFrom will panic with ErrTooLarge.
func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {}
func ReadFrom(){
    //test.txt 内容是 "未来"
    file, _ := os.Open("learngo/bytes/text.txt")
    buf := bytes.NewBufferString("Learning swift.")
    buf.ReadFrom(file)              //将text.txt内容追加到缓冲器的尾部
    fmt.Println(buf.String())
}

打印：

=======ReadFrom===

Learning swift.未来

Reset

将数据清空，没有数据可读

// Reset resets the buffer so it has no content.
// b.Reset() is the same as b.Truncate(0).
func (b *Buffer) Reset() { b.Truncate(0) }
func Reset(){
    bufs := bytes.NewBufferString("现在开始 Learning swift.")
    fmt.Println(bufs.String())

    bufs.Reset()
    fmt.Println("::已经清空了bufs的缓冲内容::")
    fmt.Println(bufs.String())
}

打印：

=======Reset======

现在开始 Learning swift.

::已经清空了bufs的缓冲内容::

string

将未读取的数据返回成 string

// String returns the contents of the unread portion of the buffer
// as a string.  If the Buffer is a nil pointer, it returns "<nil>".
func (b *Buffer) String() string {}
时间： 2024-10-06 00:10:59

Golang之bytes.buffer的相关文章

golang的bytes.buffer

参考原文:go语言的bytes.buffer 一.创建缓冲期 bytes.buffer是一个缓冲byte类型的缓冲器 1.使用bytes.NewBuffer创建:参数是[]byte的话,缓冲器里就是这个slice的内容:如果参数是nil的话,就是创建一个空的缓冲器. 2.bytes.NewBufferString创建 3.bytes.Buffer{} func main(){ buf1 := bytes.NewBufferString("hello") buf2 := bytes.Ne

golang bytes.Buffer Reset

func t() { a := []byte{'1', '2'} buf := new(bytes.Buffer) buf.Write(a) b := buf.Bytes() fmt.Println(b) buf.Reset() c := []byte{'3'} buf.Write(c) fmt.Println(b) } 上面运行结果是 [49 50][51 50] . --> 结论: bytes.Buffer Reset之后,如果再写入新的数据,如果数据的长度没有超过Reset之前缓冲区的长度

golang bytes buffer代码剖析

//上数据结构,bytes Buffer type Buffer struct { buf       []byte            // byte切片 off       int               // 从&buf[off]地址读数据, 从&buf[len(buf)]地址写数据 runeBytes [utf8.UTFMax]byte // avoid allocation of slice on each WriteByte or Rune bootstrap [64]b

golang环境protocol buffer的安装

怎么在go语言中使用google protocol Buffer呢? 1.下载相应的proto版本:https://github.com/google/protobuf/releases 2.把bin下的protoc文件 copy到GOPATH目录和/usr/local/bin目录里 3.下载protoc-gen-go插件:https://github.com/golang/protobuf/ 4.把上述文件拷贝到GOPATH路径下 5.cd到protobuf下执行make 6.到GOPATH目

GoLang之buffer与bytes包

strings包 strings包的使用举例: package main import s "strings" import "fmt" var p = fmt.Println func main() { p("Contains: ", s.Contains("test", "es")) p("Count: ", s.Count("test", "t&quo

Golang标准库之Buffer

Buffer Go标准库Buffer是一个可变大小的字节缓冲区,可以用Wirte和Read方法操作它,在Go标准库中,定义了如下关于Buffer的数据结构. type Buffer struct { buf []byte // contents are the bytes buf[off : len(buf)] off int // read at &buf[off], write at &buf[len(buf)] runeBytes [utf8.UTFMax]byte // avoid

[golang]内存不断增长bytes.makeSlice

golang写的一个图片服务器,在批量下载压缩时候发现内存不断增长.... 幸好golang自带内存占用日志结合分析工具可以方便看到内存分布. 详细可参考: http://blog.golang.org/profiling-go-programs 可以实时统计CPU\内存信息. 这里主要说一下内存怎么搞.CPU分析的参考之前的一篇文章. //需要包含这个pprof包 import "runtime/pprof" //这里接收内存统计信息保存文件 var memprofile = fla

关于golang中IO相关的Buffer类浅析

io重要的接口 在介绍buffer之前,先来认识两个重要的接口,如下边所示: type Reader interface { Read(p []byte) (n int, err error) } type Writer interface { Write(p []byte) (n int, err error) } 上边两个接口在golang sdk安装目录src/io/io.go中定义.后边凡是涉及到io相关操作的,基本上都实现了这两个接口,如: 1. package bufio 中的Rea

go语言中bytes包的常用函数，Reader和Buffer的使用

bytes中常用函数的使用: package main; import ( "bytes" "fmt" "unicode" ) //bytes包中实现了大量对[]byte操作的函数和两个最主要的Reader和Buffer两个结构 func main() { str := "aBcD"; //转为小写 fmt.Println(string(bytes.ToLower([]byte(str)))); //转为大写 fmt.Prin