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 := "Φφ kK"聽
聽聽聽聽s2 := "Φφ kK"
聽聽聽聽// 看看 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!
}
有疑问加站长微信联系（非本文作者）
