Golang學習 - bytes 包

------------------------------------------------------------

對於傳入 []byte 的函數，都不會修改傳入的參數，返回值要麼是參數的副本，要麼是參數的切片。

------------------------------------------------------------

// 轉換

// 將 s 中的全部字符修改成大寫（小寫、標題）格式返回。
func ToUpper(s []byte) []byte
func ToLower(s []byte) []byte
func ToTitle(s []byte) []byte

// 使用指定的映射表將 s 中的全部字符修改成大寫（小寫、標題）格式返回。
func ToUpperSpecial(_case unicode.SpecialCase, s []byte) []byte
func ToLowerSpecial(_case unicode.SpecialCase, s []byte) []byte
func ToTitleSpecial(_case unicode.SpecialCase, s []byte) []byte

// 將 s 中的全部單詞的首字符修改成 Title 格式返回。
// BUG: 不能很好的處理以 Unicode 標點符號分隔的單詞。
func Title(s []byte) []byte

------------------------------

// 比較

// 比較兩個 []byte，nil 參數至關於空 []byte。
// a <  b 返回 -1
// a == b 返回 0
// a >  b 返回 1
func Compare(a, b []byte) int

// 判斷 a、b 是否相等，nil 參數至關於空 []byte。
func Equal(a, b []byte) bool

// 判斷 s、t 是否類似，忽略大寫、小寫、標題三種格式的區別。
// 參考 unicode.SimpleFold 函數。
func EqualFold(s, t []byte) bool

------------------------------

// 示例：EqualFold
func main() {
	s1 := "Φφϕ kKK"
	s2 := "ϕΦφ KkK"

	// 看看 s1 裏面是什麼
	for _, c := range s1 {
		fmt.Printf("%-5x", c)
	}
	fmt.Println()
	// 看看 s2 裏面是什麼
	for _, c := range s2 {
		fmt.Printf("%-5x", c)
	}
	fmt.Println()
	// 看看 s1 和 s2 是否類似
	fmt.Println(bytes.EqualFold([]byte(s1), []byte(s2)))
}

// 輸出結果：
// 3a6  3c6  3d5  20   6b   4b   212a 
// 3d5  3a6  3c6  20   212a 6b   4b   
// true

------------------------------

// 清理

// 去掉 s 兩邊（左邊、右邊）包含在 cutset 中的字符（返回 s 的切片）
func Trim(s []byte, cutset string) []byte
func TrimLeft(s []byte, cutset string) []byte
func TrimRight(s []byte, cutset string) []byte

// 去掉 s 兩邊（左邊、右邊）符合 f 要求的字符（返回 s 的切片）
func TrimFunc(s []byte, f func(r rune) bool) []byte
func TrimLeftFunc(s []byte, f func(r rune) bool) []byte
func TrimRightFunc(s []byte, f func(r rune) bool) []byte

// 去掉 s 兩邊的空白（unicode.IsSpace）（返回 s 的切片）
func TrimSpace(s []byte) []byte

// 去掉 s 的前綴 prefix（後綴 suffix）（返回 s 的切片）
func TrimPrefix(s, prefix []byte) []byte
func TrimSuffix(s, suffix []byte) []byte

------------------------------

// 示例
func main() {
	bs := [][]byte{
		[]byte("Hello World !"),
		[]byte("Hello 世界！"),
		[]byte("hello golang ."),
	}
	f := func(r rune) bool {
		return bytes.ContainsRune([]byte("!！. "), r)
	}
	for _, b := range bs {
		fmt.Printf("%q\n", bytes.TrimFunc(b, f))
	}
	// "Hello World"
	// "Hello 世界"
	// "Hello Golang"
	for _, b := range bs {
		fmt.Printf("%q\n", bytes.TrimPrefix(b, []byte("Hello ")))
	}
	// "World !"
	// "世界！"
	// "hello Golang ."
}

------------------------------

// 拆合

// Split 以 sep 爲分隔符將 s 切分紅多個子串，結果不包含分隔符。
// 若是 sep 爲空，則將 s 切分紅 Unicode 字符列表。
// SplitN 能夠指定切分次數 n，超出 n 的部分將不進行切分。
func Split(s, sep []byte) [][]byte
func SplitN(s, sep []byte, n int) [][]byte

// 功能同 Split，只不過結果包含分隔符（在各個子串尾部）。
func SplitAfter(s, sep []byte) [][]byte
func SplitAfterN(s, sep []byte, n int) [][]byte

// 以連續空白爲分隔符將 s 切分紅多個子串，結果不包含分隔符。
func Fields(s []byte) [][]byte

// 以符合 f 的字符爲分隔符將 s 切分紅多個子串，結果不包含分隔符。
func FieldsFunc(s []byte, f func(rune) bool) [][]byte

// 以 sep 爲鏈接符，將子串列表 s 鏈接成一個字節串。
func Join(s [][]byte, sep []byte) []byte

// 將子串 b 重複 count 次後返回。
func Repeat(b []byte, count int) []byte

------------------------------

// 示例
func main() {
	b := []byte("  Hello   World !  ")
	fmt.Printf("%q\n", bytes.Split(b, []byte{' '}))
	// ["" "" "Hello" "" "" "World" "!" "" ""]
	fmt.Printf("%q\n", bytes.Fields(b))
	// ["Hello" "World" "!"]
	f := func(r rune) bool {
		return bytes.ContainsRune([]byte(" !"), r)
	}
	fmt.Printf("%q\n", bytes.FieldsFunc(b, f))
	// ["Hello" "World"]
}

------------------------------

// 子串

// 判斷 s 是否有前綴 prefix（後綴 suffix）
func HasPrefix(s, prefix []byte) bool
func HasSuffix(s, suffix []byte) bool

// 判斷 b 中是否包含子串 subslice（字符 r）
func Contains(b, subslice []byte) bool
func ContainsRune(b []byte, r rune) bool

// 判斷 b 中是否包含 chars 中的任何一個字符
func ContainsAny(b []byte, chars string) bool

// 查找子串 sep（字節 c、字符 r）在 s 中第一次出現的位置，找不到則返回 -1。
func Index(s, sep []byte) int
func IndexByte(s []byte, c byte) int
func IndexRune(s []byte, r rune) int

// 查找 chars 中的任何一個字符在 s 中第一次出現的位置，找不到則返回 -1。
func IndexAny(s []byte, chars string) int

// 查找符合 f 的字符在 s 中第一次出現的位置，找不到則返回 -1。
func IndexFunc(s []byte, f func(r rune) bool) int

// 功能同上，只不過查找最後一次出現的位置。
func LastIndex(s, sep []byte) int
func LastIndexByte(s []byte, c byte) int
func LastIndexAny(s []byte, chars string) int
func LastIndexFunc(s []byte, f func(r rune) bool) int

// 獲取 sep 在 s 中出現的次數（sep 不能重疊）。
func Count(s, sep []byte) int

------------------------------

// 替換

// 將 s 中前 n 個 old 替換爲 new，n < 0 則替換所有。
func Replace(s, old, new []byte, n int) []byte

// 將 s 中的字符替換爲 mapping(r) 的返回值，
// 若是 mapping 返回負值，則丟棄該字符。
func Map(mapping func(r rune) rune, s []byte) []byte

// 將 s 轉換爲 []rune 類型返回
func Runes(s []byte) []rune

------------------------------------------------------------

type Reader struct { ... }

// 將 b 包裝成 bytes.Reader 對象。
func NewReader(b []byte) *Reader

// bytes.Reader 實現了以下接口：
// io.ReadSeeker
// io.ReaderAt
// io.WriterTo
// io.ByteScanner
// io.RuneScanner

// 返回未讀取部分的數據長度
func (r *Reader) Len() int

// 返回底層數據的總長度，方便 ReadAt 使用，返回值永遠不變。
func (r *Reader) Size() int64

// 將底層數據切換爲 b，同時復位全部標記（讀取位置等信息）。
func (r *Reader) Reset(b []byte)

------------------------------

// 示例
func main() {
	b1 := []byte("Hello World!")
	b2 := []byte("Hello 世界！")
	buf := make([]byte, 6)
	rd := bytes.NewReader(b1)
	rd.Read(buf)
	fmt.Printf("%q\n", buf) // "Hello "
	rd.Read(buf)
	fmt.Printf("%q\n", buf) // "World!"

	rd.Reset(b2)
	rd.Read(buf)
	fmt.Printf("%q\n", buf) // "Hello "
	fmt.Printf("Size:%d, Len:%d\n", rd.Size(), rd.Len())
	// Size:15, Len:9
}

------------------------------------------------------------

type Buffer struct { ... }

// 將 buf 包裝成 bytes.Buffer 對象。
func NewBuffer(buf []byte) *Buffer

// 將 s 轉換爲 []byte 後，包裝成 bytes.Buffer 對象。
func NewBufferString(s string) *Buffer

// Buffer 自己就是一個緩存（內存塊），沒有底層數據，緩存的容量會根據須要
// 自動調整。大多數狀況下，使用 new(Buffer) 就足以初始化一個 Buffer 了。

// bytes.Buffer 實現了以下接口：
// io.ReadWriter
// io.ReaderFrom
// io.WriterTo
// io.ByteWeriter
// io.ByteScanner
// io.RuneScanner

// 未讀取部分的數據長度
func (b *Buffer) Len() int

// 緩存的容量
func (b *Buffer) Cap() int

// 讀取前 n 字節的數據並以切片形式返回，若是數據長度小於 n，則所有讀取。
// 切片只在下一次讀寫操做前合法。
func (b *Buffer) Next(n int) []byte

// 讀取第一個 delim 及其以前的內容，返回遇到的錯誤（通常是 io.EOF）。
func (b *Buffer) ReadBytes(delim byte) (line []byte, err error)
func (b *Buffer) ReadString(delim byte) (line string, err error)

// 寫入 r 的 UTF-8 編碼，返回寫入的字節數和 nil。
// 保留 err 是爲了匹配 bufio.Writer 的 WriteRune 方法。
func (b *Buffer) WriteRune(r rune) (n int, err error)

// 寫入 s，返回寫入的字節數和 nil。
func (b *Buffer) WriteString(s string) (n int, err error)

// 引用未讀取部分的數據切片（不移動讀取位置）
func (b *Buffer) Bytes() []byte

// 返回未讀取部分的數據字符串（不移動讀取位置）
func (b *Buffer) String() string

// 自動增長緩存容量，以保證有 n 字節的剩餘空間。
// 若是 n 小於 0 或沒法增長容量則會 panic。
func (b *Buffer) Grow(n int)

// 將數據長度截短到 n 字節，若是 n 小於 0 或大於 Cap 則 panic。
func (b *Buffer) Truncate(n int)

// 重設緩衝區，清空全部數據（包括初始內容）。
func (b *Buffer) Reset()

------------------------------

// 示例
func main() {
	rd := bytes.NewBufferString("Hello World!")
	buf := make([]byte, 6)
	// 獲取數據切片
	b := rd.Bytes()
	// 讀出一部分數據，看看切片有沒有變化
	rd.Read(buf)
	fmt.Printf("%s\n", rd.String()) // World!
	fmt.Printf("%s\n\n", b)         // Hello World!

	// 寫入一部分數據，看看切片有沒有變化
	rd.Write([]byte("abcdefg"))
	fmt.Printf("%s\n", rd.String()) // World!abcdefg
	fmt.Printf("%s\n\n", b)         // Hello World!

	// 再讀出一部分數據，看看切片有沒有變化
	rd.Read(buf)
	fmt.Printf("%s\n", rd.String()) // abcdefg
	fmt.Printf("%s\n", b)           // Hello World!
}

------------------------------------------------------------