> 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 {}
~~~
- 前言
- golang学习(一)之安装
- Go语言学习二:Go基础(变量、常量、数值类型、字符串、错误类型)
- Go语言学习三:Go基础(iota,array,slice,map,make,new)
- Go语言学习四:struct类型
- Ubuntu 14.04/CentOS 6.5中安装GO LANG（GO语言）
- Mac OS 安装golang
- Mac install Thrift
- Thrift RPC 使用指南实战(附golang&amp;PHP代码)
- golang net/http包使用
- 冒泡排序Bubble sort-golang
- 快速排序Quick sort - golang
- Go语言学习:Channel是什么？
- Golang的select/非缓冲的Channel实例详解
- Golang time包的定时器/断续器
- Golang同步:锁的使用案例详解
- Golang同步:条件变量和锁组合使用
- Golang同步：原子操作使用
- Golang之bytes.buffer
- Golang之字符串格式化
- Golang之反射reflect包
- Go语言配置文件解析器,类似于Windows下的INI文件.