Go语言中的bytes包

bytes包实现了操作[]byte的常用函数，本包的函数和strings包的函数类似

比较函数

Compare(a, b []byte) int      按字典顺序比较两个切片
    a == b返回 0，a < b返回 -1，a > b返回 +1
Equal(a, b []byte) bool       a 和 b 是否相等(区分大小写)
EqualFold(s, t []byte) bool   s 和 t 是否相等(不区分大小写)

连接函数

Join(s [][]byte, sep []byte) []byte   将 s 的元素使用 sep 连接起来
Repeat(b []byte, count int) []byte    将 b 重复 count 次

查找函数

字节查找
Contains(b, sub []byte) bool      b中是否包含sub
Count(s, sep []byte) int          s 中 sep 的出现次数，sep未返回len(s)+1
HasPrefix(s, prefix []byte) bool  s 前缀是否为prefix
HasSuffix(s, suffix []byte) bool  s 后缀是否为prefix
Index(s, sep []byte) int          s 中 sep 第一次出现的索引，不存在返回 -1
IndexByte(b []byte, c byte) int   b 中 c 第一次出现的索引
LastIndex(s, sep []byte) int      s 中 sep 最后一次出现的索引
LastIndexByte(s []byte, c byte) int  s 中 c 最后一次出现的索引


rune查找
ContainsAny(b []byte, chars string) bool
    b中是否包含chars中任意一个UTF-8编码的rune
ContainsFunc(b []byte, f func(rune) bool) bool
    b中是否包含任意一个满足 f(r)的rune
ContainsRune(b []byte, r rune) bool   r是否包含在b中

IndexAny(s []byte, chars string) int
    s 中chars任意一个UTF-8编码的rune首次出现的索引
IndexFunc(s []byte, f func(r rune) bool) int
    s 中第一个满足 f(c) 的UTF-8编码的rune索引
IndexRune(s []byte, r rune) int
    rune 在 s 中第一次出现的字节索引
    如果 r 不是有效的UTF-8字节，返回任何无效UTF-8字节序列第一次出现的索引
LastIndexAny(s []byte, chars string) int
    s 中chars任意一个UTF-8编码的rune最后一次出现的索引
LastIndexFunc(s []byte, f func(r rune) bool) int
    返回 s 中最后一个满足 f(c) 的rune索引

大小写转换

ToLower(s []byte) []byte   所有字母都转为小写
ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte
    相当于ToLower，但是会优先考虑 c 中的特殊大小写规则
ToTitle(s []byte) []byte   所有字母都转为标题大小写
ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte
ToUpper(s []byte) []byte   所有字母都转为大写
ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte

替换函数

ToValidUTF8(s, rep []byte) []byte
    将 s 中无效 UTF-8 字节替换为rep

Replace(s, old, new []byte, n int) []byte
    替换 s 中前 n 个 old 为 new，n < 0 表示替换次数不限制
    如果 old 为空，会在切片的开头和每个 UTF-8 字节之后匹配
ReplaceAll(s, old, new []byte) []byte
    替换所有 old 为 new，相当于Replace()中n为-1

Map(mapping func(r rune) rune, s []byte) []byte
    返回 s 所有rune均根据mapping函数进行替换后的字节副本
    如果mapping返回负值，则该字符不进行替换而是从字节切片中删除

CutPrefix(s, prefix []byte) (after []byte, found bool)
    将 s 去除前缀prefix，返回原始切片的切片，而不是副本
    返回去除前缀后的字节数组和s中前缀是否为prefix
    前缀不是prefix返回 s, false
    prefix是空字节切片返回 s, true
CutSuffix(s, suffix []byte) (before []byte, found bool)
    将 s 去除后缀suffix

Trim(s []byte, cutset string) []byte  去除cutset中包含的所有前后缀
TrimSpace(s []byte) []byte            去除 s 中所有空格前后缀
TrimFunc(s []byte, f func(r rune) bool) []byte
    去除 s 中所有满足 f(c) 的所有前后缀
TrimLeft(s []byte, cutset string) []byte 去除cutset中包含的所有前缀
TrimLeftFunc(s []byte, f func(r rune) bool) []byte
TrimRight(s []byte, cutset string) []byte  去除cutset中包含的所有后缀
TrimRightFunc(s []byte, f func(r rune) bool) []byte
TrimPrefix(s, prefix []byte) []byte      去除 s 的前缀prefix
TrimSuffix(s, suffix []byte) []byte      去除 s 的后缀prefix

分割函数

Cut(s, sep []byte) (before, after []byte, found bool)
    使用s中第一个出现的sep分割s，返回sep之前和之后的字节切片
    found表示s中是否存在sep，如不存在，返回 s,nil,false
    返回原始切片的切片，而不是副本
Fields(s []byte) [][]byte    以一个或多个连续空格字符分割
    如果 s 仅包含空格，则返回空切片
FieldsSeq(s []byte) iter.Seq[[]byte]  同Fields，但返回一个迭代器
FieldsFunc(s []byte, f func(rune) bool) [][]byte
    在满足 f(c) 的字节处分割，多个连续满足的字节视为一个分隔符
FieldsFuncSeq(s []byte, f func(rune) bool) iter.Seq[[]byte]
    效果同FieldsFunc，但是返回一个迭代器
Lines(s []byte) iter.Seq[[]byte]
    返回以换行符分割的一次性迭代器(结果包含换行符)
SplitN(s, sep []byte, n int) [][]byte
    将 s 拆分为由 sep 分隔的子切片
    如果 sep 为空，会在每个UTF-8字节后拆分
        n > 0 ：最多 n 个子切片，最后一个子切片将是未分割的余项
        n == 0：结果为 nil（零子切片）
        n < 0 ：所有子切片
Split(s, sep []byte) [][]byte
    相当于 n 为 -1 的 SplitN
SplitSeq(s, sep []byte) iter.Seq[[]byte]
    相当于Split，但是返回一个一次性迭代器
SplitAfterN(s, sep []byte, n int) [][]byte
    将 s 拆分为每个 sep 之后的子切片
    sep 为空会在每个 UTF-8 字节后进行分割
SplitAfter(s, sep []byte) [][]byte
    相当于 n 为 -1 的 SplitAfterN
SplitAfterSeq(s, sep []byte) iter.Seq[[]byte]
    相当于SplitAfter，但是返回一个一次性迭代器

其他函数

Clone(b []byte) []byte    返回 b[:len(b)] 的副本
Runes(s []byte) []rune    将UTF-8编码的 s 转换为rune切片

type Buffer struct{}

Buffer是一个可变大小的字节缓冲区，零值是一个可供使用的空缓冲区

创建Buffer

NewBuffer(buf []byte) *Buffer
    使用 buf 作为其初始内容来创建并初始化一个新的Buffer
NewBufferString(s string) *Buffer
    使用字符串 s 作为初始内容来创建并初始化一个新的Buffer

在大多数情况下，new(Buffer)或声明一个Buffer变量就足以初始化一个Buffer
buf := new(bytes.Buffer)
var buf *bytes.Buffer
buf := &bytes.Buffer{}

常用方法

Available() int    返回缓冲区中未使用的字节数
AvailableBuffer() []byte
    返回一个具有 b.Available() 容量的空缓冲区用于附加到并传递给紧接着的Buffer.Write调用
    该缓冲区仅在 b 上的下一个写入操作之前有效
Bytes() []byte
    返回一个包含缓冲区的未读部分，长度为 b.Len() 的切片
    该切片仅在下一次缓冲区修改前有效
    对切片内容的更改会影响未来读取的结果
Cap() int
    返回缓冲区底层字节切片的容量，即缓冲区的数据分配的总空间
Grow(n int)
    增大缓冲区的容量以保证至少可以将 n 个字节写入缓冲区而无需进行其他分配
Len() int
    返回缓冲区未读部分的字节数
Next(n int) []byte
    返回包含缓冲区中接下来 n 个字节的切片，并推进缓冲区，就像这些字节已由Buffer.Read返回一样
    如果缓冲区中的字节少于 n 个，返回整个缓冲区
    返回的切片仅在下次调用 read 或 write 方法之前有效
Read(p []byte) (n int, err error)
    从缓冲区读取 len(p) 个字节，或者直到缓冲区读完，返回读取的字节数
    如果缓冲区没有数据，err 为io.EOF
ReadByte() (byte, error)
    从缓冲区读取并返回下一个字节，如果没有可用字节返回错误io.EOF
ReadBytes(delim byte) (line []byte, err error)
    读取直到第一次出现delim并返回读取的切片(包含delim)
    如果在找到delim之前遇到错误会返回错误之前读取的数据和错误本身
    当且仅当返回的数据不以delim结尾时才会返回 err != nil
ReadFrom(r io.Reader) (n int64, err error)
    从 r 读取数据直到 EOF，并将其附加到缓冲区
    返回值 n 表示读取的字节数
    读取期间遇到的任何错误（io.EOF除外）也会返回
ReadRune() (r rune, size int, err error)
    从缓冲区读取并返回下一个UTF-8编码的Unicode字节
    如果没有可用字节返回错误 io.EOF
    如果字节是错误的 UTF-8 编码会消耗一个字节并返回 U+FFFD，1
ReadString(delim byte) (line string, err error)
    读取直到第一次出现delim并返回读取的字符串(包含delim)
    如果在找到delim之前遇到错误会返回错误之前读取的数据和错误本身
    当且仅当返回的数据不以delim结尾时才会返回 err != nil
Reset()
    将缓冲区重置为空，但会保留底层存储以供将来写入使用
    与Buffer.Truncate (0)相同
String() string
    以字符串形式返回缓冲区未读部分的内容
    如果缓冲区为零指针返回""
Truncate(n int)
    丢弃缓冲区中除前 n 个未读取字节之外的所有字节
    会继续使用相同的分配存储空间
UnreadByte() error
    将最近一次成功读取操作后的读取位置回退一个字节，下一次读取操作会重新读取这个字节
    如果自上次读取后发生了写入，上次读取返回错误，上次读取了零个字节，将返回错误
UnreadRune() error
    将最近一次成功读取操作后的读取位置回退一个rune，下一次读取操作会重新读取这个rune
    如果最近的读取或写入操作不是成功的Buffer.ReadRune将返回错误
Write(p []byte) (n int, err error)
    将 p 的内容追加到缓冲区，返回追加内容的长度
WriteByte(c byte) error
    将字节 c 追加到缓冲区
WriteRune(r rune) (n int, err error)
    将 Unicode 代码点 r 的 UTF-8 编码追加到缓冲区，返回其长度和错误
WriteString(s string) (n int, err error)
    将 s 的内容追加到缓冲区，返回 s 的长度
WriteTo(w io.Writer) (n int64, err error)
    将数据写入 w，直到缓冲区耗尽或发生错误
    返回写入的字节数，写入期间遇到的任何错误也会返回

type Reader struct {}

Reader用于从字节切片读取数据，Reader是只读的并且支持查找

创建Reader

NewReader(b []byte) *Reader
    返回一个从 b 读取的新Reader

常用方法

Len() int
    返回未读部分的字节数
Read(b []byte) (n int, err error)
    读取 len(b) 个字节，或者直到缓冲区读完，返回读取的字节数
    如果缓冲区没有数据，err 为io.EOF
ReadAt(b []byte, off int64) (n int, err error)
    从off偏移量读取len(p)字节数据，返回读取的字节数
ReadByte() (byte, error)
    读取单个字节并返回该字节
ReadRune() (ch rune, size int, err error)
    读取单个编码的Unicode字符，并返回该字符及其字节大小
Reset(b []byte)
    重新设置Reader的底层数据
Seek(offset int64, whence int) (int64, error)
    设置下一次读取的位置偏移量为offset
    whence表示相对于文件什么位置计算偏移量，值为预定于常量
        io.SeekStart  =0  表示文件开头
        io.SeekCurrent=1  表示当前位置
        io.SeekEnd    =2  表示文件末尾
    返回读后相对于文件开头的偏移量和错误
Size() int64
    返回底层字节切片的原始长度
WriteTo(w io.Writer) (n int64, err error)
    将数据写入w直到没有更多的数据或发生错误，返回写入的字节数