bytes标准库的介绍和使用
bytes标准库
bytes包提供了对字节切片进行读写操作的一系列函数，字节切片处理的函数比较多分为基本处理函数、比较函数、后缀检查函数、索引函数、分割函数、大小写处理函数和子切片处理函数等。
1. 常用函数
1.1 转换
| 函数 | 说明 |
|---|---|
| func ToUpper(s []byte) []byte | 将 s 中的所有字符修改为大写格式返回。 |
| func ToLower(s []byte) []byte | 将 s 中的所有字符修改为小写格式返回 |
| func ToTitle(s []byte) []byte | 将 s 中的所有字符修改为标题格式返回 |
| func ToUpperSpecial(_case unicode.SpecialCase, s []byte) []byte | 使用指定的映射表将 s 中的所有字符修改为大写格式返回 |
| func ToLowerSpecial(_case unicode.SpecialCase, s []byte) []byte | 使用指定的映射表将 s 中的所有字符修改为小写格式返回 |
| func ToTitleSpecial(_case unicode.SpecialCase, s []byte) []byte | 使用指定的映射表将 s 中的所有字符修改为标题格式返回 |
| func Title(s []byte) []byte | 将 s 中的所有单词的首字符修改为 Title 格式返回。（缺点：不能很好的处理以 Unicode 标点符号分隔的单词。） |
package main
import (
"bytes"
"fmt"
)
func main() {
var b = []byte("seafood") //强制类型转换
a := bytes.ToUpper(b)
fmt.Println(a, b)
c := b[0:4]
c[0] = 'A'
fmt.Println(c, b)
}
1.2 比较
| 函数 | 说明 |
|---|---|
| func Compare(a, b []byte) int | 比较两个 []byte，nil 参数相当于空 []byte。a < b 返回 -1；a == b 返回 0；a > b 返回 1 |
| func Equal(a, b []byte) bool | 判断 a、b 是否相等，nil 参数相当于空 []byte |
| func EqualFold(s, t []byte) bool | 判断 s、t 是否相似，忽略大写、小写、标题三种格式的区别 |
package main
import (
"bytes"
"fmt"
)
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)))
}
1.3 清理
-
func Trim(s []byte, cutset string) []byte去掉 s 两边包含在 cutset 中的字符（返回 s 的切片
-
func TrimLeft(s []byte, cutset string) []byte去掉 s 左边包含在 cutset 中的字符（返回 s 的切片）
-
func TrimRight(s []byte, cutset string) []byte去掉 s 右边包含在 cutset 中的字符（返回 s 的切片）
-
func TrimFunc(s []byte, f func(r rune) bool) []byte去掉 s 两边符合 f函数====返回值是true还是false 要求的字符（返回 s 的切片）
-
func TrimLeftFunc(s []byte, f func(r rune) bool) []byte去掉 s左边符合 f函数====返回值是true还是false 要求的字符（返回 s 的切片）
-
func TrimRightFunc(s []byte, f func(r rune) bool) []byte去掉 s右边符合 f函数====返回值是true还是false 要求的字符（返回 s 的切片）
-
func TrimSpace(s []byte) []byte去掉 s 两边的空白（unicode.IsSpace）（返回 s 的切片）
-
func TrimPrefix(s, prefix []byte) []byte去掉 s 的前缀 prefix（返回 s 的切片）
-
func TrimSuffix(s, suffix []byte) []byte去掉 s 的后缀 suffix（返回 s 的切片）
package main
import (
"bytes"
"fmt"
)
func main() {
bs := [][]byte{ //[][]byte 字节切片 二维数组
[]byte("Hello World !"),
[]byte("Hello 世界！"),
[]byte("hello golang ."),
}
f := func(r rune) bool {
return bytes.ContainsRune([]byte("!！. "), r) //判断r字符是否包含在"!！. "内
}
for _, b := range bs { //range bs 取得下标和[]byte
fmt.Printf("去掉两边: %q\n", bytes.TrimFunc(b, f)) //去掉两边满足函数的字符
}
for _, b := range bs {
fmt.Printf("去掉前缀: %q\n", bytes.TrimPrefix(b, []byte("Hello "))) //去掉前缀
}
}
1.4 拆合
-
func Split(s, sep []byte) [][]byteSplit 以 sep 为分隔符将 s 切分成多个子串，结果不包含分隔符。如果 sep 为空，则将 s 切分成 Unicode 字符列表。
-
func SplitN(s, sep []byte, n int) [][]byteSplitN 可以指定切分次数 n，超出 n 的部分将不进行切分。
-
func SplitAfter(s, sep []byte) [][]byte功能同 Split，只不过结果包含分隔符（在各个子串尾部）。
-
func SplitAfterN(s, sep []byte, n int) [][]byte功能同 SplitN，只不过结果包含分隔符（在各个子串尾部）。
-
func Fields(s []byte) [][]byte以连续空白为分隔符将 s 切分成多个子串，结果不包含分隔符。
-
func FieldsFunc(s []byte, f func(rune) bool) [][]byte以符合 f 的字符为分隔符将 s 切分成多个子串，结果不包含分隔符。
-
func Join(s [][]byte, sep []byte) []byte以 sep 为连接符，将子串列表 s 连接成一个字节串。
-
func Repeat(b []byte, count int) []byte将子串 b 重复 count 次后返回。
package main
import (
"bytes"
"fmt"
)
func main() {
b := []byte(" Hello World ! ")
fmt.Printf("b: %q\n", b)
fmt.Printf("%q\n", bytes.Split(b, []byte{' '}))
fmt.Printf("%q\n", bytes.Fields(b))
f := func(r rune) bool {
return bytes.ContainsRune([]byte(" !"), r)
}
fmt.Printf("%q\n", bytes.FieldsFunc(b, f))
}
1.5 字串
-
func HasPrefix(s, prefix []byte) bool判断 s 是否有前缀 prefix
-
func HasSuffix(s, suffix []byte) bool判断 s 是否有后缀 suffix
-
func Contains(b, subslice []byte) bool判断 b 中是否包含子串 subslice
-
func ContainsRune(b []byte, r rune) bool判断 b 中是否包含子串 字符 r
-
func ContainsAny(b []byte, chars string) bool判断 b 中是否包含 chars 中的任何一个字符
-
func Index(s, sep []byte) int查找子串 sep在 s 中第一次出现的位置，找不到则返回 -1
-
func IndexByte(s []byte, c byte) int查找子串 字节 c在 s 中第一次出现的位置，找不到则返回 -1
-
func IndexRune(s []byte, r rune) int查找子串字符 r在 s 中第一次出现的位置，找不到则返回 -1
-
func IndexAny(s []byte, chars string) int查找 chars 中的任何一个字符在 s 中第一次出现的位置，找不到则返回 -1。
-
func IndexFunc(s []byte, f func(r rune) bool) int查找符合 f 的字符在 s 中第一次出现的位置，找不到则返回 -1。
-
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功能同上，只不过查找最后一次出现的位置。
-
func Count(s, sep []byte) int获取 sep 在 s 中出现的次数（sep 不能重叠）。
package main
import (
"bytes"
"fmt"
)
func main() {
b := []byte("hello golang") //字符串强转为byte切片
sublice1 := []byte("hello")
sublice2 := []byte("Hello")
fmt.Println(bytes.Contains(b, sublice1)) //true
fmt.Println(bytes.Contains(b, sublice2)) //false
s := []byte("hellooooooooo")
sep1 := []byte("h")
sep2 := []byte("l")
sep3 := []byte("o")
fmt.Println(bytes.Count(s, sep1)) //1
fmt.Println(bytes.Count(s, sep2)) //2
fmt.Println(bytes.Count(s, sep3)) //9
}
1.6 替换
-
func Replace(s, old, new []byte, n int) []byte将 s 中前 n 个 old 替换为 new，n < 0 则替换全部。
-
func Map(mapping func(r rune) rune, s []byte) []byte将 s 中的字符替换为 mapping® 的返回值，如果 mapping 返回负值，则丢弃该字符。
-
func Runes(s []byte) []rune将 s 转换为 []rune 类型返回
package main
import (
"bytes"
"fmt"
)
func main() {
s := []byte("hello,world")
old := []byte("o")
news := []byte("ee")
fmt.Println(string(bytes.Replace(s, old, news, 0))) //hello,world
fmt.Println(string(bytes.Replace(s, old, news, 1))) //hellee,world
fmt.Println(string(bytes.Replace(s, old, news, 2))) //hellee,weerld
fmt.Println(string(bytes.Replace(s, old, news, -1))) //hellee,weerld
s1 := []byte("你好世界")
r := bytes.Runes(s1)
fmt.Println("转换前字符串的长度：", len(s1)) //12
fmt.Println("转换后字符串的长度：", len(r)) //4
}
2. Buffer类型
缓冲区是具有读取和写入方法的可变大小的字节缓冲区
Buffer的零值是准备使用的空缓冲区
type Buffer struct {
buf []byte // contents are the bytes buf[off : len(buf)]
off int // read at &buf[off], write at &buf[len(buf)]
lastRead readOp // last read operation, so that Unread* can work correctly.
}
2.1 声明buffer
-
var b bytes.Buffer直接定义一个Buffer变量，不用初始化，可以直接使用
-
b := new(bytes.Buffer)使用New返回Buffer变量
-
b := bytes.NewBuffer(s []byte)从一个[]byte切片，构造一个Buffer
-
b := bytes.NewBufferString(s string)从一个string变量，构造一个Buffer
2.2 往Buffer中写入数据
-
b.Write(d []byte)将切片d写入Buffer数据
-
b.WriteString(s string)将字符串s写入Buffer尾部
-
b.WriteByte(c byte)将字符c写入Buffer尾部
-
b.WriteRune(r rune)将一个rune类型的数据放到缓冲器的尾部
-
b.WriteTo(w io.Writer)将Buffer中的内容输出到实现了io.Writer接口的可写入对象中
2.3 从Buffer中读取数据
-
b.Read(c)一次读取8个byte到c容器中，每次读取新的8个byte覆盖c中原来的内容
-
b.ReadByte()读取第一个byte，b的第一个byte被拿掉，赋值给 a => a, _ := b.ReadByte()
-
b.ReadRune()读取第一个rune，b的第一个rune被拿掉，赋值给 r => r, _ := b.ReadRune()
-
b.ReadBytes(delimiter byte)需要一个byte作为分隔符，读的时候从缓冲器里找第一个出现的分隔符（delim），找到后，把从缓冲器头部开始到分隔符之间的所有byte进行返回，作为byte类型的slice，返回后，缓冲器也会空掉一部分
-
b.ReadString(delimiter byte)需要一个byte作为分隔符，读的时候从缓冲器里找第一个出现的分隔符（delim），找到后，把从缓冲器头部开始到分隔符之间的所有byte进行返回，作为字符串返回，返回后，缓冲器也会空掉一部分
-
b.ReadFrom(i io.Reader)从一个实现io.Reader接口的r，把r里的内容读到缓冲器里，n返回读的数量
package main
import (
"bytes"
"fmt"
)
func main() {
rd := bytes.NewBufferString("Hello World!")
buf := make([]byte, 6)
// 获取数据切片
b := rd.Bytes()
// 读出一部分数据，看看切片有没有变化
rd.Read(buf)
fmt.Printf("%s\n", rd.String())
fmt.Printf("%s\n\n", b)
// 写入一部分数据，看看切片有没有变化
rd.Write([]byte("abcdefg"))
fmt.Printf("%s\n", rd.String())
fmt.Printf("%s\n\n", b)
// 再读出一部分数据，看看切片有没有变化
rd.Read(buf)
fmt.Printf("%s\n", rd.String())
fmt.Printf("%s\n", b)
}
2.4 其他方法
-
func (b *Buffer) Len() int未读取部分的数据长度
-
func (b *Buffer) Cap() int获取缓存的容量
-
func (b *Buffer) Next(n int) []byte读取前 n 字节的数据并以切片形式返回，如果数据长度小于 n，则全部读取。切片只在下一次读写操作前合法。
-
func (b *Buffer) Bytes() []byte引用未读取部分的数据切片（不移动读取位置）
-
func (b *Buffer) String() string返回未读取部分的数据字符串（不移动读取位置）
-
func (b *Buffer) Grow(n int)自动增加缓存容量，以保证有 n 字节的剩余空间。如果 n 小于 0 或无法增加容量则会 panic。
-
func (b *Buffer) Truncate(n int)将数据长度截短到 n 字节，如果 n 小于 0 或大于 Cap 则 panic。
-
func (b *Buffer) Reset()重设缓冲区，清空所有数据（包括初始内容）。
3. Reader类型
type Reader struct {
s []byte
i int64 // current reading index
prevRune int // index of previous rune; or < 0
}
Reader实现了io.Reader, io.ReaderAt, io.WriterTo, io.Seeker, io.ByteScanner, io.RuneScanner接口
-
func NewReader(b []byte) *Reader将 b 包装成 bytes.Reader 对象。
-
func (r *Reader) Len() int返回未读取部分的数据长度
-
func (r *Reader) Size() int64返回底层数据的总长度，方便 ReadAt 使用，返回值永远不变。
-
func (r *Reader) Reset(b []byte)将底层数据切换为 b，同时复位所有标记（读取位置等信息）。
package main
import (
"bytes"
"fmt"
)
func main() {
data := "123456789"
//通过[]byte创建Reader
re := bytes.NewReader([]byte(data))
//返回未读取部分的长度
fmt.Println("re len : ", re.Len())
//返回底层数据总长度
fmt.Println("re size : ", re.Size())
fmt.Println("---------------")
buf := make([]byte, 2)
for {
//读取数据
n, err := re.Read(buf)
if err != nil {
break
}
fmt.Println(string(buf[:n]))
}
}
package main
import (
"bytes"
"fmt"
)
func main() {
data := "123456789"
//通过[]byte创建Reader
re := bytes.NewReader([]byte(data))
buf := make([]byte, 2)
re.Seek(0, 0)
//设置偏移量
for {
//一个字节一个字节的读
b, err := re.ReadByte()
if err != nil {
break
}
fmt.Println(string(b))
}
fmt.Println("----------------")
re.Seek(0, 0)
off := int64(0)
for {
//指定偏移量读取
n, err := re.ReadAt(buf, off)
if err != nil {
break
}
off += int64(n)
fmt.Println(off, string(buf[:n]))
}
}