Golang之bytes.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)

}

输出：

向 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())

打印：

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())

打印：

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())

打印：

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())

打印：

完整演示样例

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))

}

打印：

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))

}

打印：

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))

}

打印：

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())

}

打印：

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())

}

打印：

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