golang语言中bytes包的常用函数，Reader和Buffer的使用

package main;

import (
"bytes"
"fmt"
"unicode"
)

//bytes包中实现了大量对[]byte操作的函数和两个最主要的Reader和Buffer两个结构

func main() {
str := "aBcD";
//转为小写
fmt.Println(string(bytes.ToLower([]byte(str))));
//转为大写
fmt.Println(string(bytes.ToUpper([]byte(str))));
//转为标题，
fmt.Println(string(bytes.ToTitle([]byte(str))));

//自定义映射表
mycase := unicode.SpecialCase{
unicode.CaseRange{
//1,1表示替换规则只影响1到1之间的字符
1,
1,
[unicode.MaxCase]rune{
//大写转换
'壹' - 1,
//小写转换
'一' - 1,
//标题转换
'小' - 1,
},
},
unicode.CaseRange{
2,
2,
[unicode.MaxCase]rune{
'贰' - 2,
'二' - 2,
'中' - 2,
},
},
unicode.CaseRange{
3,
3,
[unicode.MaxCase]rune{
'叁' - 3,
'三' - 3,
'大' - 3,
},
},
};
//使用映射表将[]byte中字符修改为小写
data := bytes.ToLowerSpecial(
mycase,
[]byte{1, 2, 3},
)
fmt.Println(string(data));
//使用映射表将[]byte中字符修改为大写
data = bytes.ToUpperSpecial(
mycase,
[]byte{1, 2, 3},
);
fmt.Println(string(data));
//使用映射表将[]byte中字符修改为标题
data = bytes.ToTitleSpecial(
mycase,
[]byte{1, 2, 3},
);
fmt.Println(string(data));

//将[]byte中单词首字符修改为Title并返回
fmt.Println(string(bytes.Title([]byte("abc def"))));

//比较两个[]byte，
// a < b 返回 -1
// a == b 返回 0
// b > b 返回 1
fmt.Println(bytes.Compare([]byte("a"), []byte("b")));

//比较两个[]byte是否相等
fmt.Println(bytes.Equal([]byte("abc"), []byte("abc")));

//比较两个[]byte是否相等，忽略大写，小写，标题
fmt.Println(bytes.EqualFold([]byte("ABC"), []byte("abc")));

//去掉[]byte两边包含在cutset中的字符
fmt.Println(string(bytes.Trim([]byte(" abc "), " ")));

//去掉左边包含在cutset中的字符
fmt.Println(string(bytes.TrimLeft([]byte(" abc "), " ")));

//去掉右边包含在cutset中的字符
fmt.Println(string(bytes.TrimRight([]byte(" abc "), " ")));

//去掉两边空白字符
fmt.Println(string(bytes.TrimSpace([]byte(" abc "))));

//去掉前缀
fmt.Println(string(bytes.TrimPrefix([]byte("tb_user"), []byte("tb_"))));

//去掉后缀
fmt.Println(string(bytes.TrimSuffix([]byte("user_idx"), []byte("_idx"))));

//以sep为分隔符，切分为多个[]byte
tmp := bytes.Split([]byte("ab cd ef"), []byte(" "));
for _, v := range tmp {
fmt.Println(string(v));
}

//分割最多n个子切片，超出n的部分将不进行切分
tmp = bytes.SplitN([]byte("ab cd ef"), []byte(" "), 2);
for _, v := range tmp {
fmt.Println(string(v));
}

//以sep为分隔符，切分为多个[]byte，结果包含分隔符，在子串尾部
tmp = bytes.SplitAfter([]byte("ab,cd,ef"), []byte(","));
for _, v := range tmp {
fmt.Println(string(v));
}

//分割最多n个子切片，超出n的部分将不进行切分
tmp = bytes.SplitAfterN([]byte("ab,cd,ef"), []byte(","), 2);
for _, v := range tmp {
fmt.Println(string(v));
}

//以空白字符切分
tmp = bytes.Fields([]byte("a b c d"));
for _, v := range tmp {
fmt.Println(string(v));
}

//以符合函数的字符作为分隔符来切分
tmp = bytes.FieldsFunc([]byte("asbscsd"), func(r rune) bool {
if r == rune('s') {
return true;
}
return false;
});
for _, v := range tmp {
fmt.Println(string(v));
}

//以sep为连接符，拼接[][]byte
fmt.Println(string(bytes.Join(
[][]byte{
[]byte("aa"),
[]byte("bb"),
[]byte("cc"),
},
[]byte("-"),
)));

//重复[]byte，Count次
fmt.Println(string(bytes.Repeat([]byte("abc"), 3)));

//判断是否有前缀
fmt.Println(bytes.HasPrefix([]byte("is_true"), []byte("is_")));

//判断是否有后缀
fmt.Println(bytes.HasSuffix([]byte("chk_on"), []byte("_on")));

//判断是否包含某个[]byte
fmt.Println(bytes.Contains([]byte("i am jack"), []byte("jack")));

//判断是否包含某个rune
fmt.Println(bytes.ContainsRune([]byte("i from 中国"), rune('中')));

//查找sep在参数一中第一次出现的位置，找不到返回-1
fmt.Println(bytes.Index([]byte("abcabc"), []byte("a")));
fmt.Println(bytes.IndexByte([]byte("cba"), 'a'));
fmt.Println(bytes.IndexRune([]byte("i from 中国"), rune('中')));

//查找chars中任意一个字符在参数一中出现的位置，找不到返回-1
fmt.Println(bytes.IndexAny([]byte("hello world"), "xy"));

//功能同上，只不过查找最后一次出现的位置
fmt.Println(bytes.LastIndex([]byte("abcabc"), []byte("a")));
fmt.Println(bytes.LastIndexByte([]byte("cba"), 'a'));
fmt.Println(bytes.LastIndexAny([]byte("hello world"), "xy"));

//获取sep中在参数一中出现的次数
fmt.Println(bytes.Count([]byte("a|b|c"), []byte("|")));

//将参数一中前n个old替换成new，n小于0则全部替换。
fmt.Println(string(
bytes.Replace(
[]byte("i am jack"),
[]byte("i am"),
[]byte("我是"),
-1,
),
));

//将[]byte中的字符替换为函数的返回值，如果返回值为负数，则丢弃访字符。
fmt.Println(string(
bytes.Map(
func(r rune) rune {
if r == 'a' {
return 'A';
} else if r == 'c' {
return -1;
}
return r;
},
[]byte("abcd"),
),
));

//将[]byte转换为[]rune
fmt.Println(string(bytes.Runes([]byte("我是谁"))));
}

package main;

import (
"bytes"
"fmt"
)

//bytes中Reader和Buffer两个结构的使用

func useReader() {
data := "abcdefghijk";
//通过[]byte创建Reader
re := bytes.NewReader([]byte(data));
//返回未读取部分的长度
fmt.Println("re len : ", re.Len());
//返回底层数据总长度
fmt.Println("re size : ", re.Size());

buf := make([]byte, 2);
for {
//读取数据
n, err := re.Read(buf);
if err != nil {
break;
}
fmt.Println(string(buf[:n]));
};

//设置偏移量，因为上面的操作已经修改了读取位置等信息
re.Seek(0, 0);
for {
//一个字节一个字节的读
b, err := re.ReadByte();
if err != nil {
break;
}
fmt.Println(string(b));
}

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]));
}
}

func useBuffer() {
data := "123456789";
//通过[]byte创建一个Buffer
bf := bytes.NewBuffer([]byte(data));

//Len()返回未读取的数据长度
fmt.Println("bf len : ", bf.Len());

//Cap()缓存容量
fmt.Println("bf cap : ", bf.Cap());

//Bytes()返回未读取的数据切片
bys := bf.Bytes();
for _, v := range bys {
fmt.Print(string(v) + " ");
}
fmt.Println();

//Next()返回未读取部分前n字节数据的切片
for i := 0; i < 10; i++ {
tmp := bf.Next(1);
fmt.Print(string(tmp) + " ");
}
fmt.Println();
//再次Next，返回[]byte，说明没有未读取的
fmt.Println(bf.Next(1));

//重设缓冲，丢弃全部内容
bf.Reset();

//通过string创建Buffer
bf2 := bytes.NewBufferString(data);
//读取第一个 delim 及其之前的内容，返回遇到的错误
line, _ := bf2.ReadBytes('3');
fmt.Println(string(line));
//效果同上，返回string
line2, _ := bf2.ReadString('7');
fmt.Println(line2);

//创建一个空Buffer
bf3 := bytes.Buffer{};
//自动增加缓存容量，保证有n字节剩余空间
bf3.Grow(16);
//写入rune编码，返回写入的字节数和错误。
n, _ := bf3.WriteRune(rune('中'));
fmt.Println("bf3 write ", n);
n, _ = bf3.WriteString("国人");
fmt.Println("bf3 write ", n);
//返回未读取的字符串
fmt.Println(bf3.String());
//将数据长度截断到n字节
bf3.Truncate(6);
fmt.Println(bf3.String());
}

func main() {
//防止main中代码过多，我新建两个函数单独写
useReader();
useBuffer();
}