go語言的bytes.buffer

##bytes.buffer是 bytes.buffer是一個緩衝byte類型的緩衝器，這個緩衝器裏存放着都是byte

##建立一個緩衝器 ###NewBuffer
若是在使用bytes.NewBuffer的時候，參數是[]byte的slice的話
緩衝器裏就是這個slice的內容，若是參數是nil的話，意思是New一個空的緩衝器裏
###NewBufferString
還能夠用bytes.NewBufferString("hello")來創建一個內容是hello的緩衝器

buf1:=bytes.NewBufferString("hello")
buf2:=bytes.NewBuffer([]byte("hello"))
buf3:=bytes.NewBuffer([]byte{"h","e","l","l","o"})
以上三者等效
buf4:=bytes.NewBufferString("")
buf5:=bytes.NewBuffer([]byte{})
以上二者等效

若是buffer在new的時候是空的也不要緊，由於能夠用Write來寫入，寫在尾部

##寫入到緩衝器（緩衝器變大） ###Write---- func (b *Buffer) Write(p []byte) (n int, err error) 使用Write方法，將一個byte類型的slice放到緩衝器的尾部

package main

import (
    "bytes"
    "fmt"
)

func main() {
    s := []byte(" world")
    buf := bytes.NewBufferString("hello")
    fmt.Println(buf.String())  //buf.String()方法是吧buf裏的內容轉成string，以便於打印
    buf.Write(s) //將s這個slice寫到buf的尾部
    fmt.Println(buf.String())  //打印 hello world
}

###WriteString---- func (b *Buffer) WriteString(s string) (n int, err error) 使用WriteString方法，將一個字符串放到緩衝器的尾部

package main

import (
    "bytes"
    "fmt"
)

func main() {
    s := " world"
    buf := bytes.NewBufferString("hello")
    fmt.Println(buf.String())  //buf.String()方法是吧buf裏的內容轉成string，以便於打印
    buf.WriteString(s) //將s這個string寫到buf的尾部
    fmt.Println(buf.String())  //打印 hello world
}

###WriteByte---- func (b *Buffer) WriteByte(c byte) error 使用WriteByte方法，將一個byte類型的數據放到緩衝器的尾部

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var s byte = '!'
    buf := bytes.NewBufferString("hello")
    fmt.Println(buf.String())  //buf.String()方法是吧buf裏的內容轉成string，以便於打印
    buf.WriteByte(s) //將s這個string寫到buf的尾部
    fmt.Println(buf.String())  //打印 hello!
}

###WriteRune---- func (b *Buffer) WriteRune(r rune) (n int, err error) 使用WriteRune方法，將一個rune類型的數據放到緩衝器的尾部

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var s rune = '好'
    buf := bytes.NewBufferString("hello")
    fmt.Println(buf.String())  //buf.String()方法是吧buf裏的內容轉成string，以便於打印
    buf.WriteRune(s) //將s這個string寫到buf的尾部
    fmt.Println(buf.String())  //打印 hello好
}

##從緩衝器寫出（緩衝器變小） ###WriteTo---- func (b *Buffer) WriteTo(w io.Writer) (n int64, err error) 使用WriteTo方法，將一個緩衝器的數據寫到w裏，w是實現io.Writer的，好比os.File就是實現io.Writer

package main

import (
    "bytes"
    "fmt"
    "os"
)

func main() {
    file , _ := os.Create("text.txt")
    buf := bytes.NewBufferString("hello")
    buf.WriteTo(file) //hello寫到text.txt文件中了
    fmt.Fprintf(file, buf.String()) //雖然這不在討論範圍，但這句效果同上
}

##讀出緩衝器（緩衝器變小） ###Read----func (b *Buffer) Read(p []byte) (n int, err error) 給Read方法一個容器p，讀完後，p就滿了，緩衝器相應的減小了，返回的n爲成功讀的數量
如，緩衝器是一個裝滿5升水的杯子，這個杯子有Read方法，給Read方法一個3升的杯子
Read完後，5升杯子裏有2升水，3升的杯子滿了，返回的n爲3 在一次Read時，5升杯子裏有0升水，3升的杯子仍是滿的，但其中有2升的水被新倒入的水替代了，返回的n爲2

package main
import(
    "fmt"
    "bytes"
)

func main() {
    s1:=[]byte("hello")                //申明一個slice爲s1
    buff:=bytes.NewBuffer(s1)     //new一個緩衝器buff，裏面存着hello這5個byte
    s2:=[]byte(" world")                 //申明另外一個slice爲s2
    buff.Write(s2)                     //把s2寫入添加到buff緩衝器內
    fmt.Println(buff.String())            //使用緩衝器的String方法轉成字符串，並打印："hello world"
    
    s3:=make([]byte,3)               //申明一個空的slice爲s3，容量爲3
    buff.Read(s3)                       //把buff的內容讀入到s3內，由於s3的容量爲3，因此只讀了3個過來
    fmt.Println(buff.String())       //buff的前3個字符被讀走了，因此buff變成："lo world"
    fmt.Println(string(s3))          //空的s3被寫入3個字符，因此爲"hel"
    buff.Read(s3)                       //把buff的內容讀入到s3內，由於s3的容量爲3，因此只讀了3個過來，原來s3的內容被覆蓋了
    fmt.Println(buff.String())       //buff的前3個字符又被讀走了，因此buff變成："world"
    fmt.Println(string(s3))          //原來的s3被從"hel"變成"lo "，由於"hel"被覆蓋了
}

###ReadByte---- func (b *Buffer) ReadByte() (c byte, err error) 返回緩衝器頭部的第一個byte，緩衝器頭部第一個byte被拿掉

package main

import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBufferString("hello")
    fmt.Println(buf.String()) //buf.String()方法是吧buf裏的內容轉成string，>以便於打印
    b, _ := buf.ReadByte()    //讀取第一個byte，賦值給b
    fmt.Println(buf.String()) //打印 ello，緩衝器頭部第一個h被拿掉
    fmt.Println(string(b))    //打印 h
}

###ReadRune---- func (b *Buffer) ReadRune() (r rune, size int, err error) ReadRune和ReadByte很像 返回緩衝器頭部的第一個rune，緩衝器頭部第一個rune被拿掉

package main

import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBufferString("好hello")
    fmt.Println(buf.String()) //buf.String()方法是吧buf裏的內容轉成string，>以便於打印
    b, n, _ := buf.ReadRune() //讀取第一個rune，賦值給b
    fmt.Println(buf.String()) //打印 hello
    fmt.Println(string(b))    //打印中文字： 好，緩衝器頭部第一個「好」被拿掉
    fmt.Println(n)            //打印3，「好」做爲utf8儲存佔3個byte
    b, n, _ = buf.ReadRune()  //再讀取第一個rune，賦值給b
    fmt.Println(buf.String()) //打印 ello
    fmt.Println(string(b))    //打印h，緩衝器頭部第一個h被拿掉
    fmt.Println(n)            //打印 1，「h」做爲utf8儲存佔1個byte
}

###ReadBytes---- func (b *Buffer) ReadBytes(delim byte) (line []byte, err error) ReadBytes和ReadByte根本就不是一回事，MD
ReadBytes須要一個byte做爲分隔符，讀的時候從緩衝器裏找第一個出現的分隔符（delim），找到後，把從緩衝器頭部開始到分隔符之間的全部byte進行返回，做爲byte類型的slice，返回後，緩衝器也會空掉一部分

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var d byte = 'e' //分隔符爲e
    buf := bytes.NewBufferString("hello")
    fmt.Println(buf.String()) //buf.String()方法是吧buf裏的內容轉成string，以便於打印
    b, _ := buf.ReadBytes(d)  //讀到分隔符，並返回給b
    fmt.Println(buf.String()) //打印 llo，緩衝器被取走一些數據
    fmt.Println(string(b))    //打印 he，找到e了，將緩衝器從頭開始，到e的內容都返回給b
}

###ReadString---- func (b *Buffer) ReadString(delim byte) (line string, err error) ReadBytes和ReadString基本就是一回事
ReadBytes須要一個byte做爲分隔符，讀的時候從緩衝器裏找第一個出現的分隔符（delim），找到後，把從緩衝器頭部開始到分隔符之間的全部byte進行返回，做爲字符串，返回後，緩衝器也會空掉一部分

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var d byte = 'e' //分隔符爲e
    buf := bytes.NewBufferString("hello")
    fmt.Println(buf.String()) //buf.String()方法是吧buf裏的內容轉成string，以便於打印
    b, _ := buf.ReadString(d)  //讀到分隔符，並返回給b
    fmt.Println(buf.String()) //打印 llo，緩衝器被取走一些數據
    fmt.Println(b)    //打印 he，找到e了，將緩衝器從頭開始，到e的內容都返回給b
}

##讀入緩衝器（緩衝器變大） ###ReadFrom---- func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) 從一個實現io.Reader接口的r，把r裏的內容讀到緩衝器裏，n返回讀的數量

package main

import (
    "bytes"
    "fmt"
    "os"
)

func main() {
    file, _ := os.Open("test.txt")  //test.txt的內容是「world」
    buf := bytes.NewBufferString("hello ")
    buf.ReadFrom(file)              //將text.txt內容追加到緩衝器的尾部
    fmt.Println(buf.String())    //打印「hello world」
}

##從緩衝器取出（緩衝器變小） ###Next ---- func (b *Buffer) Next(n int) []byte 返回前n個byte，成爲slice返回，原緩衝器變小

package main

import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBufferString("hello")
    fmt.Println(buf.String())
    b := buf.Next(2)   //重頭開始，取2個
    fmt.Println(buf.String())  //變小了
    fmt.Println(string(b))   //打印he
}

##其餘未說起 ###之後再寫 Len Grow Reset Truncate UnreadRune UnreadByte