go语言的魔幻旅程18-bytes包

天下熙熙皆为利来，天下攘攘皆为利往

这段时间在不知不觉中又被动的学会了一个新的“成语”－潘嘎之交，想必不需要我在此在此普及故事的又来，但凡是稍微关注点热点新闻的人肯定对此不会感觉到陌生，但其中的两个梗确实值得令人玩味，这两个梗基本是出自潘之口。第一个梗：“嘎子，网络的东西是虚拟的，水很深，你把握不住”，网友调侃：潘叔能把握，因为叔是长江。另一个梗是：“嘎子你还年轻，不应该把时间浪费在带货直播上”，网友调侃道：“嘎子你还年轻，挣钱的时间还很多，让潘叔先挣，毕竟潘叔的年龄大了”。互联网技术越发达，大跌眼镜的事情不断增多，潘嘎之交是也许不是第一个，但类似的事情绝对不会是最后一个

go语言的bytes包

go语言的bytes包主要提供一些操作字节切片的函数和方法，下面将针对这个部分的内容展开讲解。

package main

import (
	"bytes"
	"fmt"
)

/*********************************************************************/
/**************** golang中bytes包相关API讲解 ***********************/
/********************************************************************/

/*
Constants
Variables
func Compare(a, b []byte) int
func Contains(b, subslice []byte) bool
func ContainsAny(b []byte, chars string) bool
func ContainsRune(b []byte, r rune) bool
func Count(s, sep []byte) int
func Equal(a, b []byte) bool
func EqualFold(s, t []byte) bool
func Fields(s []byte) [][]byte
func FieldsFunc(s []byte, f func(rune) bool) [][]byte
func HasPrefix(s, prefix []byte) bool
func HasSuffix(s, suffix []byte) bool
func Index(s, sep []byte) int
func IndexAny(s []byte, chars string) int
func IndexByte(b []byte, c byte) int
func IndexFunc(s []byte, f func(r rune) bool) int
func IndexRune(s []byte, r rune) int
func Join(s [][]byte, sep []byte) []byte
func LastIndex(s, sep []byte) int
func LastIndexAny(s []byte, chars string) int
func LastIndexByte(s []byte, c byte) int
func LastIndexFunc(s []byte, f func(r rune) bool) int
func Map(mapping func(r rune) rune, s []byte) []byte
func Repeat(b []byte, count int) []byte
func Replace(s, old, new []byte, n int) []byte
func ReplaceAll(s, old, new []byte) []byte
func Runes(s []byte) []rune
func Split(s, sep []byte) [][]byte
func SplitAfter(s, sep []byte) [][]byte
func SplitAfterN(s, sep []byte, n int) [][]byte
func SplitN(s, sep []byte, n int) [][]byte
func Title(s []byte) []byte
func ToLower(s []byte) []byte
func ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte
func ToTitle(s []byte) []byte
func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte
func ToUpper(s []byte) []byte
func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte
func ToValidUTF8(s, replacement []byte) []byte
func Trim(s []byte, cutset string) []byte
func TrimFunc(s []byte, f func(r rune) bool) []byte
func TrimLeft(s []byte, cutset string) []byte
func TrimLeftFunc(s []byte, f func(r rune) bool) []byte
func TrimPrefix(s, prefix []byte) []byte
func TrimRight(s []byte, cutset string) []byte
func TrimRightFunc(s []byte, f func(r rune) bool) []byte
func TrimSpace(s []byte) []byte
func TrimSuffix(s, suffix []byte) []byte
type Buffer
    func NewBuffer(buf []byte) *Buffer
    func NewBufferString(s string) *Buffer
    func (b *Buffer) Bytes() []byte
    func (b *Buffer) Cap() int
    func (b *Buffer) Grow(n int)
    func (b *Buffer) Len() int
    func (b *Buffer) Next(n int) []byte
    func (b *Buffer) Read(p []byte) (n int, err error)
    func (b *Buffer) ReadByte() (byte, error)
    func (b *Buffer) ReadBytes(delim byte) (line []byte, err error)
    func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error)
    func (b *Buffer) ReadRune() (r rune, size int, err error)
    func (b *Buffer) ReadString(delim byte) (line string, err error)
    func (b *Buffer) Reset()
    func (b *Buffer) String() string
    func (b *Buffer) Truncate(n int)
    func (b *Buffer) UnreadByte() error
    func (b *Buffer) UnreadRune() error
    func (b *Buffer) Write(p []byte) (n int, err error)
    func (b *Buffer) WriteByte(c byte) error
    func (b *Buffer) WriteRune(r rune) (n int, err error)
    func (b *Buffer) WriteString(s string) (n int, err error)
    func (b *Buffer) WriteTo(w io.Writer) (n int64, err error)
type Reader
    func NewReader(b []byte) *Reader
    func (r *Reader) Len() int
    func (r *Reader) Read(b []byte) (n int, err error)
    func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
    func (r *Reader) ReadByte() (byte, error)
    func (r *Reader) ReadRune() (ch rune, size int, err error)
    func (r *Reader) Reset(b []byte)
    func (r *Reader) Seek(offset int64, whence int) (int64, error)
    func (r *Reader) Size() int64
    func (r *Reader) UnreadByte() error
    func (r *Reader) UnreadRune() error
    func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
Bugs
*/

func main() {
	/**
	*Compare函数返回一个整数表示两个[]byte切片按字典序比较的结果,
	*如果a==b返回0；如果a<b返回-1；否则返回+1。nil参数视为空切片。
	*func Compare(a, b []byte) int
	*/

	/*
	a := []byte("abc")
	b := []byte("a")
	fmt.Println(bytes.Compare(a, b))

	b = []byte("abcd")
	fmt.Println(bytes.Compare(a, b))

	b = []byte("abc")
	fmt.Println(bytes.Compare(a, b))
	*/

	/**
	*判断切片b是否包含子切片subslice。
	*func Contains(b, subslice []byte) bool
	*/

	/*
	b := []byte("abc")
	sub := []byte("a")
	fmt.Println(bytes.Contains(b, sub))

	sub = []byte("cv")
	fmt.Println(bytes.Contains(b, sub))
	*/

	/**
	*判断char中任何UTF-8编码的代码点是否在b之内
	*func ContainsAny(b []byte, chars string) bool
	 */

	/*
	fmt.Println(bytes.ContainsAny([]byte("I like sead."), "fÄo!"))
	fmt.Println(bytes.ContainsAny([]byte("I like seafood."), "去是伟大的."))
	fmt.Println(bytes.ContainsAny([]byte("I like seafood."), ""))
	fmt.Println(bytes.ContainsAny([]byte(""), ""))
	*/


	/**
	*判断ｒ是否包含在UTF-8编码的字符切片b中
	*func ContainsRune(b []byte, r rune) bool
	*/

	/*
	fmt.Println(bytes.ContainsRune([]byte("I like seafood."), 'f'))
	fmt.Println(bytes.ContainsRune([]byte("I like seafood."), 'ö'))
	fmt.Println(bytes.ContainsRune([]byte("去是伟大的!"), '大'))
	fmt.Println(bytes.ContainsRune([]byte("去是伟大的!"), '!'))
	fmt.Println(bytes.ContainsRune([]byte(""), '@'))
	*/

	/**
	*Count计算s中有多少个不重叠的sep子切片。
	*func Count(s, sep []byte) int
	*/

	/*
	fmt.Println(bytes.Count([]byte("cheese"), []byte("e")))
	fmt.Println(bytes.Count([]byte("five"), []byte("")))
	*/

	/**
	*判断a和b是否长度相同且包含相同字节。 nil参数等效于空片
	*func Equal(a, b []byte) bool
	*/

	/*
	fmt.Println(bytes.Equal([]byte("Go"), []byte("Go")))
	fmt.Println(bytes.Equal([]byte("Go"), []byte("C++")))
	*/

	/**
	*判断两个utf-8编码切片（将unicode大写、小写、标题三种格式字符视为相同）是否相同.
	*func EqualFold(s, t []byte) bool
	*/

	/*
	fmt.Println(bytes.EqualFold([]byte("Go"), []byte("go")))
	*/

	/**
	*返回将字符串按照空白（unicode.IsSpace确定，可以是一到多个连续
        *的空白字符分割的多个子切片。
	*如果字符串全部是空白或者是空字符串的话，会返回空切片。
	*func Fields(s []byte) [][]byte
	*/

	/*
	fmt.Printf("Fields are: %q", bytes.Fields([]byte("  foo bar  baz   ")))
	*/

	/**
	*类似Fields，但使用函数f来确定分割符（满足f的utf-8码值）。
        *如果字符串全部是分隔符或者是空字符串的话，会返回空切片。
	*func FieldsFunc(s []byte, f func(rune) bool) [][]byte
	*/

	/*
	f := func(c rune) bool {
		return !unicode.IsLetter(c) && !unicode.IsNumber(c)
	}
	fmt.Printf("Fields are: %q", bytes.FieldsFunc([]byte("  foo1;bar2,baz3..."), f))
	*/


	/**
	*HasPrefix测试字节片s是否以前缀开头
	*func HasPrefix(s, prefix []byte) bool
	*/

	/*
	fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("Go")))
	fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("C")))
	fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("")))
	*/

	/**
	*HasSuffix测试字节片s是否以后缀结尾。
	*func HasSuffix(s, suffix []byte) bool
	*/

	/*
	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("go")))
	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("O")))
	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("Ami")))
	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("")))
	*/


	/**
	*Index返回s中sep的第一个实例的索引；如果s中不存在sep，则返回-1。
	*func Index(s, sep []byte) int
	*/

	/*
	fmt.Println(bytes.Index([]byte("chicken"), []byte("ken")))
	fmt.Println(bytes.Index([]byte("chicken"), []byte("dmr")))
	*/

	/**
	*IndexAny将s解释为UTF-8编码的Unicode代码点的序列。它返回char中任何Unicode码点中
	*s中第一次出现的字节索引。如果char为空或没有共同的代码点，则返回-1。
	*func IndexAny(s []byte, chars string) int
	*/

	/*
	fmt.Println(bytes.IndexAny([]byte("chicken"), "aeiouy"))
	fmt.Println(bytes.IndexAny([]byte("crwth"), "aeiouy"))
	*/

	/**
	*IndexByte返回b中c的第一个实例的索引；如果b中不存在c，则返回-1。
	*func IndexByte(b []byte, c byte) int
	*/

	/*
	fmt.Println(bytes.IndexByte([]byte("chicken"), byte('k')))
	fmt.Println(bytes.IndexByte([]byte("chicken"), byte('g')))
	*/

	/**
	*IndexFunc将s解释为UTF-8编码的代码点的序列。它返回满足f(c)的第一个
        *Unicode代码点的s中的字节索引，如果没有，则返回-1。
	*func IndexFunc(s []byte, f func(r rune) bool) int
	*/

	/*
	f := func(c rune) bool {
		return unicode.Is(unicode.Han, c)
	}
	fmt.Println(bytes.IndexFunc([]byte("Hello, 世界"), f))
	fmt.Println(bytes.IndexFunc([]byte("Hello, world"), f))
	*/


	/**
	*IndexRune将s解释为UTF-8编码的代码点的序列。它返回给定符文中s中第一次出现的字节索引。
	*如果s中不存在符文，则返回-1。如果r为utf8.RuneError，它将返回任何无效UTF-8字节序列的第一个实例。
	*func IndexRune(s []byte, r rune) int
	*/

	/*
	fmt.Println(bytes.IndexRune([]byte("chicken"), 'k'))
	fmt.Println(bytes.IndexRune([]byte("chicken"), 'd'))
	*/

	/**
	*Join将s的元素连接起来以创建一个新的字节片。分隔符sep放置在所得切片中的元素之间。
	*func Join(s [][]byte, sep []byte) []byte
	*/

	/*
	s := [][]byte{[]byte("foo"), []byte("bar"), []byte("baz")}
	fmt.Printf("%s", bytes.Join(s, []byte(", ")))
	*/

	/**
	*LastIndex返回s中sep的最后一个实例的索引；如果s中不存在sep，则返回-1。
	*func LastIndex(s, sep []byte) int
	*/

	/*
	fmt.Println(bytes.Index([]byte("go gopher"), []byte("go")))
	fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("go")))
	fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("rodent")))
	*/

	/**
	*LastIndexAny将s解释为UTF-8编码的Unicode代码点的序列。它返回char中任何Unicode码点中s
	*中最后一次出现的字节索引。如果char为空或没有共同的代码点，则返回-1。
	*func LastIndexAny(s []byte, chars string) int
	*/

	/*
	fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "MüQp"))
	fmt.Println(bytes.LastIndexAny([]byte("go 地鼠"), "地大"))
	fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "z,!."))
	*/

	/**
	*LastIndexByte返回s中c的最后一个实例的索引；如果s中不存在c，则返回-1。
	*func LastIndexByte(s []byte, c byte) int
	*/

	/*
	fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('g')))
	fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('r')))
	fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('z')))
	*/

	/**
	*LastIndexFunc将s解释为一系列UTF-8编码的代码点。它返回满足f(c)的最后一个Unicode
	*代码点的s中的字节索引，如果没有，则返回-1。
	*func LastIndexFunc(s []byte, f func(r rune) bool) int
	*/

	/*
	fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsLetter))
	fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsPunct))
	fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsNumber))
	*/


	/**
	*Map返回字节片s的副本，其所有字符都根据映射函数进行了修改。如果映射返回负值，
        *则将字符从字节片中丢弃，并且不进行替换。 s中的字符和输出被解释为UTF-8编码的代码点。
	*func Map(mapping func(r rune) rune, s []byte) []byte
	*/

	/*
	rot13 := func(r rune) rune {
		switch {
		case r >= 'A' && r <= 'Z':
			return 'A' + (r-'A'+13)%26
		case r >= 'a' && r <= 'z':
			return 'a' + (r-'a'+13)%26
		}
		return r
	}
	fmt.Printf("%s", bytes.Map(rot13, []byte("'Twas brillig and the slithy gopher...")))
	*/

	/**
	*返回count个b串联形成的新的切片。
	*func Repeat(b []byte, count int) []byte
	*/

	/*
	fmt.Printf("ba%s", bytes.Repeat([]byte("na"), 2))
	*/

	/**
	*Replace将返回slice的副本，其中有old的前n个非重叠实例被new取代。如果old为空，
	*则它在切片的开头和每个UTF-8序列之后匹配，最多产生k + 1个k-rune切片的替换。
        *如果n <0，则替换次数没有限制。
	*func Replace(s, old, new []byte, n int) []byte
	*/

	/*
	fmt.Printf("%s\n", bytes.Replace([]byte("oink oink oink"), []byte("k"), []byte("ky"), 2))
	fmt.Printf("%s\n", bytes.Replace([]byte("oink oink oink"), []byte("oink"), []byte("moo"), -1))
	*/


	/**
	*则它在切片的开头和每个UTF-8序列之后匹配，最多产生k + 1个k-rune切片的替换。
        *如果n <0，则替换次数没有限制。
	*func ReplaceAll(s, old, new []byte) []byte
	*/

	/*
	fmt.Printf("%s\n", bytes.ReplaceAll([]byte("oink oink oink"), []byte("oink"), []byte("moo")))
	*/

	/**
	*符文将s解释为UTF-8编码的代码点序列。它返回与s等效的一片符文(Unicode代码点)。
	*func Runes(s []byte) []rune
	*/

	/*
	rs := bytes.Runes([]byte("go gopher"))
	for _, r := range rs {
		fmt.Printf("%#U\n", r)
	}
	*/

	/**
	*将片段s分割为所有由sep分隔的子片段，并返回这些分隔符之间的子片段的片段。如果sep为空，
	*则Split在每个UTF-8序列后拆分。它等效于SplitN，计数为-1。
	*func Split(s, sep []byte) [][]byte
	*/

	/*
	fmt.Printf("%q\n", bytes.Split([]byte("a,b,c"), []byte(",")))
	fmt.Printf("%q\n", bytes.Split([]byte("a man a plan a canal panama"), []byte("a ")))
	fmt.Printf("%q\n", bytes.Split([]byte(" xyz "), []byte("")))
	fmt.Printf("%q\n", bytes.Split([]byte(""), []byte("Bernardo O'Higgins")))
	*/

	/**
	*在Sep的每个实例之后，SplitAfter将s切片为所有子切片，并返回这些子切片的切片。如果sep为空，
	*则SplitAfter在每个UTF-8序列之后拆分。它等效于SplitAfterN，计数为-1。
	*func SplitAfter(s, sep []byte) [][]byte
	*/

	/*
	fmt.Printf("%q\n", bytes.SplitAfter([]byte("a,b,c"), []byte(",")))
	*/

	/**
	*在Sep的每个实例之后，SplitAfterN将s切片为子切片，并返回这些子切片的切片。如果sep为空，
	*则SplitAfterN在每个UTF-8序列之后拆分。计数确定要返回的子切片数：
	*func SplitAfterN(s, sep []byte, n int) [][]byte
	*/

	/*
	fmt.Printf("%q\n", bytes.SplitAfterN([]byte("a,b,c"), []byte(","), 2))
	*/

	/**
	*将SplitN的s切片成由sep分隔的子切片，并返回这些分隔符之间的子切片的切片。如果sep为空，
	*则SplitN在每个UTF-8序列之后分割。计数确定要返回的子切片数：
	*func SplitN(s, sep []byte, n int) [][]byte
	*/

	/*
	fmt.Printf("%q\n", bytes.SplitN([]byte("a,b,c"), []byte(","), 2))
	z := bytes.SplitN([]byte("a,b,c"), []byte(","), 0)
	fmt.Printf("%q (nil = %v)\n", z, z == nil)
	*/

	/**
	*Title将s视为UTF-8编码的字节，并返回一个包含所有Unicode字母的副本，该副本以单词开头的所有
	*Unicode字母映射到其标题大小写。
	*func Title(s []byte) []byte
	*/

	/*
	fmt.Printf("%s", bytes.Title([]byte("her royal highness")))
	*/


	/**
	*ToLower返回字节片s的副本，其中所有Unicode字母均映射为小写字母。
	*func ToLower(s []byte) []byte
	*/

	/*
	fmt.Printf("%s", bytes.ToLower([]byte("Gopher")))
	*/

	/**
	*ToLowerSpecial将s视为UTF-8编码的字节，并返回一个副本，其中所有Unicode字母均映射为小写字母，
	*并优先使用特殊的大小写规则。
	*func ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte
	*/

	/*
	str := []byte("AHOJ VÝVOJÁRİ GOLANG")
	totitle := bytes.ToLowerSpecial(unicode.AzeriCase, str)
	fmt.Println("Original : " + string(str))
	fmt.Println("ToLower : " + string(totitle))
	*/

	/**
	*ToTitle将s视为UTF-8编码的字节，并返回一个副本，其中所有Unicode字母均映射到其标题大小写
	*func ToTitle(s []byte) []byte
	*/

	/*
	fmt.Printf("%s\n", bytes.ToTitle([]byte("loud noises")))
	fmt.Printf("%s\n", bytes.ToTitle([]byte("хлеб")))
	*/

	/**
	*ToTitleSpecial将s视为UTF-8编码的字节，并返回一个副本，其中所有Unicode字母均映射到其标题大小写，
	*并优先使用特殊大小写规则。
	*func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte
	*/

	/*
	str := []byte("ahoj vývojári golang")
	totitle := bytes.ToTitleSpecial(unicode.AzeriCase, str)
	fmt.Println("Original : " + string(str))
	fmt.Println("ToTitle : " + string(totitle))
	*/

	/**
	*ToUpper返回字节片s的副本，其中所有Unicode字母都映射到其大写形式。
	*func ToUpper(s []byte) []byte
	*/

	/*
	fmt.Printf("%s", bytes.ToUpper([]byte("Gopher")))
	*/

	/**
	*ToUpperSpecial将s视为UTF-8编码的字节，并返回一个副本，其中所有Unicode字母
	*均映射为它们的大写字母，优先考虑特殊的大小写规则。
	*func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte
	*/

	/*
	str := []byte("ahoj vývojári golang")
	totitle := bytes.ToUpperSpecial(unicode.AzeriCase, str)
	fmt.Println("Original : " + string(str))
	fmt.Println("ToUpper : " + string(totitle))
	*/

	/**
	*返回给定字节切片的副本，每次运行的无效UTF-8字节序列由给定切片替换
	*func ToValidUTF8(s, replacement []byte) []byte
	*/

	/*
	fmt.Printf("%q\n", bytes.ToValidUTF8([]byte("abcfd\xc3\xb1"), []byte("nn")))
	*/

	/**
	*Trim通过切掉cutset中包含的所有前导和尾随UTF-8编码的代码点来返回s的子片段。
	*func Trim(s []byte, cutset string) []byte
	*/

	/*
	fmt.Printf("[%q]", bytes.Trim([]byte(" !!! Achtung! Achtung! !!! "), "! "))
	*/

	/**
	*TrimFunc通过分割满足f(c)的所有前导和尾随UTF-8编码的代码点c来返回s的子项。
	*func TrimFunc(s []byte, f func(r rune) bool) []byte
	*/

	/*
	fmt.Println(string(bytes.TrimFunc([]byte("go-gopher!"), unicode.IsLetter)))
	fmt.Println(string(bytes.TrimFunc([]byte("\"go-gopher!\""), unicode.IsLetter)))
	fmt.Println(string(bytes.TrimFunc([]byte("go-gopher!"), unicode.IsPunct)))
	fmt.Println(string(bytes.TrimFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
	*/

	/**
	*TrimLeft通过切掉cutset中包含的所有前导UTF-8编码的代码点来返回s的子片段。
	*func TrimLeft(s []byte, cutset string) []byte
	*/

	/*
	fmt.Print(string(bytes.TrimLeft([]byte("453gopher8257"), "0123456789")))
	*/

	/**
	*TrimLeftFunc将s视为UTF-8编码的字节，并通过分割满足f(c)的所有前
	*导UTF-8编码的代码点c来返回s的子片段。
	*func TrimLeftFunc(s []byte, f func(r rune) bool) []byte
	*/

	/*
	fmt.Println(string(bytes.TrimLeftFunc([]byte("go-gopher"), unicode.IsLetter)))
	fmt.Println(string(bytes.TrimLeftFunc([]byte("go-gopher!"), unicode.IsPunct)))
	fmt.Println(string(bytes.TrimLeftFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
	*/

	/**
	*TrimPrefix返回s，而没有提供的前导前缀字符串。如果s不以前缀开头，则s不变返回。
	*func TrimPrefix(s, prefix []byte) []byte
	*/

	/*
	var b = []byte("Goodbye,, world!")
	b = bytes.TrimPrefix(b, []byte("Goodbye,"))
	b = bytes.TrimPrefix(b, []byte("See ya,"))
	fmt.Printf("Hello%s", b)
	*/


	/**
	*TrimRight通过切掉cutset中包含的所有尾随UTF-8编码的代码点来返回s的子片段。
	*func TrimRight(s []byte, cutset string) []byte
	*/

	/*
	fmt.Print(string(bytes.TrimRight([]byte("453gopher8257"), "0123456789")))
	*/


	/**
	*TrimRightFunc通过分割满足f(c)的所有尾随UTF-8编码的代码点c来返回s的子片段。
	*func TrimRightFunc(s []byte, f func(r rune) bool) []byte
	*/

	/*
	fmt.Println(string(bytes.TrimRightFunc([]byte("go-gopher"), unicode.IsLetter)))
	fmt.Println(string(bytes.TrimRightFunc([]byte("go-gopher!"), unicode.IsPunct)))
	fmt.Println(string(bytes.TrimRightFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
	*/

	/**
	*TrimSpace通过切掉Unicode定义的所有前导和尾随空格来返回s的子片段。
	*func TrimSpace(s []byte) []byte
	*/

	/*
	fmt.Printf("%s", bytes.TrimSpace([]byte(" \t\n a lone gopher \n\t\r\n")))
	*/

	/**
	*TrimSuffix返回s，但不提供结尾的后缀字符串。如果s不以后缀结尾，则s不变返回。
	*func TrimSuffix(s, suffix []byte) []byte
	*/

	/*
	var b = []byte("Hello, goodbye, etc!")
	b = bytes.TrimSuffix(b, []byte("goodbye, etc!"))
	b = bytes.TrimSuffix(b, []byte("gopher"))
	b = append(b, bytes.TrimSuffix([]byte("world!"), []byte("x!"))...)
	os.Stdout.Write(b)
	*/

	/*********************************************************************/
	/**************** bytes包中Buffer结构体方法API *********************/
	/*******************************************************************/


	/**
	*NewBuffer使用buf作为初始内容创建并初始化一个Buffer。本函数用于创建
        *一个用于读取已存在数据的buffer；也用于指定用于写入的内部缓冲的大小，
        *此时，buf应为一个具有指定容量但长度为0的切片。buf会被作为返回值
	*的底层缓冲切片。
	*func NewBuffer(buf []byte) *Buffer
	*/

	/*
	var b bytes.Buffer
	b1 := new(bytes.Buffer)
	b2 := bytes.NewBuffer([]byte("I love Golang"))
	b3 := bytes.NewBufferString("xueshop.cn")
	fmt.Println(b, b1, b2, b3)
	*/


	/**
	*NewBuffer使用buf作为初始内容创建并初始化一个Buffer。本函数用于创建一个用于
        *读取已存在数据的buffer；
	*func NewBufferString(s string) *Buffer
	*/

	var b bytes.Buffer
	b = *bytes.NewBufferString("xueshop.cn")
	fmt.Printf("%q\n", b)
}

小结

bytes包部分的内容整体而言，内容相对较多，函数的相关知识点也是非常重要的，基本上针对文件、流的操作都会设计到其中类库的调用的操作，从某种程度上来讲，bytes包的内容是核心中的核心，也是必须拿下来的关键阵地。