零基础 go - 39(字符串常用的系统函数）

1、统计字符串的长度，按字节

• len(s) 返回字符串s的字节长度

pacakge mian

import "fmt"

func main() {
    s := "hello世界"
    fmt.Println(len(s)) // 输出11，因为中文字符占3个字节
}

2、字符串遍历，同时处理有中文问题

• 当字符串有中文可以这样处理 -》 r := []rune(str)

pacakge mian

import "fmt"

func main() {
    s := "hello世界"
    for i := 0; i < len(s); i++ {
        fmt.Printf("%c ", s[i]) // 输出 h e l l o ? ? 因为s[i]是按字节访问的，中文字符占3个字节，所以会输出乱码
    }




    // 有中文可以这样处理
    r := []rune(s)
    for i := 0; i < len(r); i++ {
        fmt.Printf("%c ", r[i]) // 输出 h e l l o 世 界
    }
}

3、字符串转整数 & 整数转字符串 -- strconv.Atoi(s) & strconv.Itoa(n)

• 字符串转整数： n,er := strconv.Atoi(s)
• 整数转字符串： s := strconv.Itoa(n)

pacakge mian

import (
    "fmt"
    "strconv"
)

func main() {
    // 字符串转整数
    s := "123"
    n, err := strconv.Atoi(s)
    if err != nil {
        fmt.Println("转换错误", err)
    } else {
        fmt.Println(n) // 输出 123，n是整数类型
    }


    // 如果字符串有非数字字符，转换会失败
    s2 := "123abc"
    n2, err2 := strconv.Atoi(s2)
    if err2 != nil {
        fmt.Println("转换错误", err2) // 输出 转换错误 strconv.Atoi: parsing "123abc": invalid syntax
    } else {
        fmt.Println(n2) // 不会执行
    }

    // 整数转字符串
    n3 := 456
    s3 := strconv.Itoa(n3)
    fmt.Println(s3) // 输出 "456"，s3是字符串类型
}

3、字符串转 []byte & []byte转字符串 -- []byte(s) & string(b)

• 字符串转 []byte： b := []byte(s)
• []byte转字符串： s := string(b)

pacakge mian

import (
    "fmt"
    _ "strconv"
)

func main() {
    // 字符串转 []byte
    s := "hello"
    b := []byte(s)
    fmt.Println(b) // 输出 [104 101 108 108 111]，b是一个字节切片，每个元素是s中对应字符的ASCII码




    // []byte转字符串
    b2 := []byte{119, 111, 114, 108, 100}
    s2 := string(b2)
    fmt.Println(s2) // 输出 "world"，s2是字符串类型，由b2中的字节转换而来
}

4、十进制转2 8 16 进制

• 十进制转二进制： strconv.FormatInt(n, 2)
• 十进制转八进制： strconv.FormatInt(n, 8)
• 十进制转十六进制： strconv.FormatInt(n, 16)

pacakge mian
import (
    "fmt"
    "strconv"
)

func main() {
    n := 123
    // 十进制转二进制
    s2 := strconv.FormatInt(int64(n), 2)
    fmt.Println(s2) // 输出 "1111011"


    // 十进制转八进制
    s8 := strconv.FormatInt(int64(n), 8)
    fmt.Println(s8) // 输出 "173"


    // 十进制转十六进制
    s16 := strconv.FormatInt(int64(n), 16)
    fmt.Println(s16) // 输出 "7b"
}

5、查找子串是否在指定的字符串中 -- strings.Contains(s, substr)

• 查找子串： strings.Contains(s, substr) 返回bool值，表示substr是否在s中出现过

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "hello world"
    // 查找子串
    fmt.Println(strings.Contains(s, "world")) // 输出 true，因为"world"在s中出现过
    fmt.Println(strings.Contains(s, "golang")) // 输出 false，因为"golang"不在s中出现过
}

6、统计子串在指定字符串中出现的次数 -- strings.Count(s, substr)

• 统计子串出现次数： strings.Count(s, substr) 返回substr在s中出现的次数

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "hello world, hello golang"
    // 统计子串出现次数
    fmt.Println(strings.Count(s, "hello")) // 输出 2，因为"hello"在s中出现了两次
    fmt.Println(strings.Count(s, "world")) // 输出 1，因为"world"在s中出现了1次
    fmt.Println(strings.Count(s, "golang")) // 输出 1，因为"golang"在s中出现了1次
    fmt.Println(strings.Count(s, "java")) // 输出 0，因为"java"在s中没有出现过
}

7、不区分大小写的字符串比较 -- strings.EqualFold(s1, s2)

• 字符串比较： strings.EqualFold(s1, s2) 返回bool
• == 是区分大小写的字符串比较，只有s1和s2完全相同且大小写一致时才返回true

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s1 := "Hello"
    s2 := "hello"
    s3 := "HELLO"

    // 字符串比较
    fmt.Println(strings.EqualFold(s1, s2)) // 输出 true，因为s1和s2不区分大小写后是相等的
    fmt.Println(strings.EqualFold(s1, s3)) // 输出 true，因为s1和s3不区分大小写后是相等的
    fmt.Println(strings.EqualFold(s2, s3)) // 输出 true，因为s2和s3不区分大小写后是相等的
    fmt.Println(s1 == s2) // 输出 false，因为s1和s2区分大小写后不相等

    s4 := "Hello "
    // 即使s4和s1只有一个空格的差别，EqualFold也会返回false
    fmt.Println(strings.EqualFold(s1, s4)) // 输出 false，因为s1和s4即使不区分大小写也不完全相等
}

8、返回子串在字符串中第一次出现的位置 -- strings.Index(s, substr)

• 查找子串位置： strings.Index(s, substr) 返回substr在s中第一次出现的位置（以字节为单位），如果substr不在s中出现过，则返回-1

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "hello world, hello golang"
    // 查找子串位置
    strings.Index(s, "world") // 返回 6，因为"world"在s中第一次出现的位置是第6个字节（从0开始计数）
    strings.Index(s, "golang") // 返回 19，因为"golang"在s中第一次出现的位置是第19个字节
    strings.Index(s, "java") // 返回 -1，因为"java"在s中没有出现过
}

9、返回子串在字符串中最后一次出现的位置 -- strings.LastIndex(s, substr)

• 查找子串最后位置： strings.LastIndex(s, substr) 返回substr在s中最后一次出现的位置（以字节为单位），如果substr不在s中中出现过，则返回-1

pacakge mian
import (
    "fmt"
    "strings"
)

func main() {
    s := "hello world, hello golang"
    // 查找子串最后位置
    fmt.Println(strings.LastIndex(s, "hello")) // 输出 13，因为"hello"在s中最后一次出现的位置是第13个字节
    fmt.Println(strings.LastIndex(s, "world")) // 输出 6，因为"world"在s中最后一次出现的位置是第6个字节
    fmt.Println(strings.LastIndex(s, "java")) // 输出 -1，因为"java"在s中没有出现过
}

10、将指定的子串替换成另一个子串 -- strings.Replace(s, old, new, n)

• 替换子串： strings.Replace(s, old, new, n)
• 将s中的前n个old子串替换成new，如果n小于0，则替换所有的old子串

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "hello world, hello golang"

    // 替换子串
    fmt.Println(strings.Replace(s, "hello", "hi", 1)) // 输出 "hi world, hello golang"，只替换了第一个"hello"

    fmt.Println(strings.Replace(s, "hello", "hi", -1)) // 输出 "hi world, hi golang"，替换了所有的"hello"

    fmt.Println(strings.Replace(s, "java", "python", -1)) // 输出 "hello world, hello golang"，因为"java"在s中没有出现过，所以没有替换任何内容
}

11、将字符串按照指定的分隔符切割成子串数组 -- strings.Split(s, sep)

• 字符串切割： strings.Split(s, sep) 返回一个字符串数组
• 将s按照sep分隔符切割成多个子串，并返回一个字符串数组，如果s中没有sep，则返回一个长度为1的数组，包含s本身，如果s和sep都是空字符串，则返回一个空数组

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "hello,world,go,golang"
    // 字符串切割
    fmt.Println(strings.Split(s, ",")) // 输出 [hello world go golang]，将s按照逗号切割成4个子串，返回一个字符串数组

    fmt.Println(len(strings.Split(s, ","))) // 输出 4，切割后的字符串数组长度是4




    fmt.Println(strings.Split(s, ";")) // 输出 [hello,world,go,golang]，因为s中没有分号，所以返回一个长度为1的数组，包含s本身
    fmt.Println(len(strings.Split(s, ";"))) // 输出 1，切割后的字符串数组长度是1

    fmt.Println(strings.Split("", ",")) // 输出 []，将空字符串按照逗号切割，返回一个长度为1的数组，包含空字符串
    fmt.Println(len(strings.Split("", ","))) // 输出 1，切割后的字符串数组长度是1
    
    fmt.Println(strings.Split("", "")) // 输出 []，将空字符串按照空字符串切割，返回一个空数组
    fmt.Println(len(strings.Split("", ""))) // 输出 0，切割后的字符串数组长度是0
}

12、将字符串字母进行大小写转换 -- strings.ToUpper(s) & strings.ToLower(s) & strings.ToTitle(s)

• strings.ToUpper(s) 将s中的字母转换成大写
• strings.ToLower(s) 将s中的字母转换成小写
• string.ToUpper和strings.ToLower只会转换字母字符，其他字符（如数字、标点、空格等）不会受到影响
• strings.ToUpper和strings.ToLower会返回一个新的字符串，原字符串s不会被修改
• strings.ToTitle(s) 将s中的每个单词的首字母转换成大写，其他字母转换成小写

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "Hello World"
    // 字符串大小写转换
    fmt.Println(strings.ToUpper(s)) // 输出 "HELLO WORLD"，将s中的字母转换成大写
    fmt.Println(strings.ToLower(s)) // 输出 "hello world"，将s中的字母转换成小写
    fmt.Println(strings.ToTitle(s)) // 输出 "Hello World"，将s中的每个单词的首字母转换成大写，其他字母转换成小写

}

13、去除字符串两端的空格 -- strings.TrimSpace(s)

• 去除空格： strings.TrimSpace(s) 返回一个新的字符串，去除了s两端的空格字符（包括空格、制表符、换行符等Unicode定义的空白字符）
• strings.TrimSpace只会去除字符串两端的空格字符，字符串中间的空格不会被去除
• 如果s中没有空格字符，或者s是一个空字符串，则返回s本身

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := " hello world "
    fmt.Println(strings.TrimSpace(s)) // 输出 "hello world"，去除了s两端的空格字符


    s1 := ""
    fmt.Println(strings.TrimSpace(s1)) // 输出 ""，s1是一个空字符串，返回s1本身
}

14、将字符串左右两边指定的字符去除 -- strings.Trim(s, cutset)

• 去除指定字符： strings.Trim(s, cutset) 返回一个新的字符串
• 去除s两端的cutset中包含的字符，直到遇到第一个不在cutset中的字符为止，字符串中间的字符不会被去除
• 如果s两端的字符都在cutset中，则会被全部去除，如果s中没有cutset中的字符，或者s是一个空字符串，则返回s本身

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "!!hello world!!"
    fmt.Println(strings.Trim(s, "!")) // 输出 "hello world"，去除了s两端的"!"字符
    s1 := "abcdehello worldedcba"
    fmt.Println(strings.Trim(s1, "abcde")) // 输出 "hello world"，去除了s1两端的"a"、"b"、"c"、"d"、"e"字符
    s2 := "hello world"
    fmt.Println(strings.Trim(s2, "xyz")) // 输出 "hello world"，因为s2两端没有"x"、"y"、"z"字符，所以返回s2本身
    s3 := ""
    fmt.Println(strings.Trim(s3, "abc")) // 输出 ""，s3是一个空字符串，返回s3本身
}

15、将字符串左右两边指定的字符去除 -- strings.TrimLeft(s, cutset) & strings.TrimRight(s, cutset)

• 去除指定字符： strings.TrimLeft(s, cutset) & strings.TrimRight(s, cutset) 返回一个新的字符串
• strings.TrimLeft(s, cutset) 去除s左边的cutset中包含的字符，直到遇到第一个不在cutset中的字符为止
• strings.TrimRight(s, cutset) 去除s右边的cutset中包含的字符，直到遇到第一个不在cutset中的字符为止
• 字符串中间的字符不会被去除，如果s两端的字符都在cutset中，则会被全部去除，如果s中没有cutset中的字符，或者s是一个空字符串，则返回s本身

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "!!hello world!!"
    fmt.Println(strings.TrimLeft(s, "!")) // 输出 "hello world!!"，去除了s左边的"!"字符
    fmt.Println(strings.TrimRight(s, "!")) // 输出 "!!hello world"，去除了s右边的"!"字符
    s1 := "abcdehello worldedcba"
    fmt.Println(strings.TrimLeft(s1, "abcde")) // 输出 "hello worldedcba"，去除了s1左边的"a"、"b"、"c"
    fmt.Println(strings.TrimRight(s1, "abcde")) // 输出 "abcdehello world"，去除了s1右边的"a"、"b"、"c"、"d"、"e"字符
    s2 := "hello world"
    fmt.Println(strings.TrimLeft(s2, "xyz")) // 输出 "hello world"，因为s2左边没有"x"、"y"、"z"字符，所以返回s2 本身
    fmt.Println(strings.TrimRight(s2, "xyz")) // 输出 "hello world"，因为s2右边没有"x"、"y"、"z"字符，所以返回s2 本身
    s3 := ""
    fmt.Println(strings.TrimLeft(s3, "abc")) // 输出 ""，s3是一个空字符串，返回s3本身
    fmt.Println(strings.TrimRight(s3, "abc")) // 输出 ""，s3是一个空字符串，返回s3本身
}

16、将字符串左右两边指定的子串去除 -- strings.TrimPrefix(s, prefix) & strings.TrimSuffix(s, suffix)

• 去除指定子串： strings.TrimPrefix(s, prefix) & strings.TrimSuffix(s, suffix) 返回一个新的字符串
• strings.TrimPrefix(s, prefix) 去除s左边的prefix子串，如果s以prefix开头，则返回去除prefix后的字符串，否则返回s本身
• strings.TrimSuffix(s, suffix) 去除s右边的suffix子串，如果s以suffix结尾，则返回去除suffix后的字符串，否则返回s本身
• 字符串中间的子串不会被去除，如果s以prefix开头但不以suffix结尾，或者以suffix结尾但不以prefix开头，或者s中既没有prefix也没有suffix，则返回s本身

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "hello world"
    fmt.Println(strings.TrimPrefix(s, "hello")) // 输出 " world"，去除了s左边的"hello"子串
    fmt.Println(strings.TrimSuffix(s, "world")) // 输出 "hello "，去除了s右边的"world"子串
    fmt.Println(strings.TrimPrefix(s, "hi")) // 输出 "hello world"，因为s不以"hi"开头，所以返回s本身
    fmt.Println(strings.TrimSuffix(s, "golang")) // 输出 "hello world"，因为s不以"golang"结尾，所以返回s本身
}

17、判断字符串是否以指定的子串开头或结尾 -- strings.HasPrefix(s, prefix) & strings.HasSuffix(s, suffix)

• 判断字符串开头： strings.HasPrefix(s, prefix) 返回bool值，表示s是否以prefix子串开头
• 判断字符串结尾： strings.HasSuffix(s, suffix) 返回bool值，表示s是否以suffix子串结尾

pacakge mian

import (
    "fmt"
    "strings"
)

func main() {
    s := "hello world"
    fmt.Println(strings.HasPrefix(s, "hello")) // 输出 true，因为s以"hello"开头
    fmt.Println(strings.HasSuffix(s, "world")) // 输出 true，因为s以"world"结尾
    fmt.Println(strings.HasPrefix(s, "hi")) // 输出 false，因为s不以"hi"开头
    fmt.Println(strings.HasSuffix(s, "golang")) // 输出 false，因为s不以"golang"结尾
}

备注（总结）

strings 包中常用函数：

• 1. strings.Contains(s, substr) 判断字符串s是否包含substr
• 2. strings.HasPrefix(s, prefix) 判断字符串s是否以prefix开头
• 3. strings.HasSuffix(s, suffix) 判断字符串s是否以suffix结尾
• 4. strings.Index(s, substr) 返回substr在s中第一次出现的位置，如果没有返回-1
• 5. strings.LastIndex(s, substr) 返回substr在s中最后一次出现的位置，如果没有返回-1
• 6. strings.Replace(s, old, new, n) 将s中的old替换为new，n表示替换的次数，-1表示全部替换
• 7. strings.ReplaceAll(s, old, new) 将s中的old替换为new，返回替换后的字符串
• 8. strings.Split(s, sep) 将s按照sep分割成一个字符串切片
• 9. strings.Join(a []string, sep string) 将字符串切片a中的元素用sep连接成一个字符串
• 10. strings.Trim(s, cutset) 去掉s两端的cutset中的字符

• 11.strings.TrimLeft(s, cutset) 去掉s左端的cutset中的字符

• 12.strings.TrimRight(s, cutset) 去掉s右端的cutset中的字符

• 13. strings.TrimSpace(s) 去掉s两端的空白字符
• 14. strings.ToLower(s) 将s中的字母转换为小写
• 15. strings.ToUpper(s) 将s中的字母转换为大写
• 16. strings.Title(s) 将s中的每个单词的首字母转换为大写
• 17. strings.Repeat(s, count) 将s重复count次
• 18. strings.Fields(s) 将s按照空白字符分割成一个字符串切片
• 20. strings.EqualFold(s, t) 判断s和t是否相等，忽略大小写
• 19. strings.Map(mapping, s) 将s中的每个字符按照mapping函数进行映射转换
• 21. strings.Compare(s, t) 比较s和t的大小，返回-1表示s < t，返回0表示s == t，返回1表示s > t
• 22. strings.Count(s, substr) 返回substr在s中出现的次数
• 23. strings.Duplicate(s) 返回s的一个副本
• 24. strings.NewReplacer(oldnew ...string) 返回一个Replacer，可以用来进行多个字符串的替换
• 25. strings.NewReader(s) 返回一个Reader，可以用来读取字符串s
• 26. strings.Builder 用于高效地构建字符串
• 27. strings.Reader 用于读取字符串
• 28. strings.SplitN(s, sep, n) 将s按照sep分割成n个子字符串，最后一个子字符串包含剩余的部分
• 29. strings.SplitAfter(s, sep) 将s按照sep分割成一个字符串切片，sep作为切分结果的一部分
• 30. strings.SplitAfterN(s, sep, n) 将s按照sep分割成n个子字符串，sep作为切分结果的一部分，最后一个子字符串包含剩余的部分
• 31. strings.TrimPrefix(s, prefix) 去掉s开头的prefix
• 32. strings.TrimSuffix(s, suffix) 去掉s结尾的suffix
• 33. strings.Cut(s, sep) 将s切割成两部分，sep作为分隔符，返回切割后的两部分和一个布尔值表示是否切割成功
• 34. strings.CutPrefix(s, prefix) 如果s以prefix开头，则返回去掉prefix后的字符串和true，否则返回s和false
• 35. strings.CutSuffix(s, suffix) 如果s以suffix结尾，则返回去掉suffix后的字符串和true，否则返回s和false
• 36. strings.HasAny(s, chars) 判断s中是否包含chars中的任意字符
• 37. strings.IndexAny(s, chars) 返回s中第一个出现chars中任意字符的位置，如果没有返回-1
• 38. strings.LastIndexAny(s, chars) 返回s中最后一个出现chars中任意字符的位置，如果没有返回-1
• 39. strings.TrimFunc(s, f) 去掉s两端满足f函数条件的字符
• 40. strings.TrimLeftFunc(s, f) 去掉s左端满足f函数条件的字符
• 41. strings.TrimRightFunc(s, f) 去掉s右端满足f函数条件的字符
• 42. strings.FieldsFunc(s, f) 将s按照满足f函数条件的字符分割成一个字符串切片
• 43. strings.ToValidUTF8(s, replacement) 将s中的无效UTF-8字符替换为replacement
• 44. strings.ToTitle(s) 将s中的字母转换为标题格式，即每个单词的首字母大写，其他字母小写
• 45. strings.ToTitleSpecial(caser, s) 根据指定的caser将s中的字母转换为标题格式
• 46. strings.ToLowerSpecial(caser, s) 根据指定的caser将s中的字母转换为小写
• 47. strings.ToUpperSpecial(caser, s) 根据指定的caser将s中的字母转换为大写

bytes 包中常用函数：

• 1. bytes.Contains(b, subslice) 判断字节切片b是否包含subslice
• 2. bytes.HasPrefix(b, prefix) 判断字节切片b是否以prefix开头
• 3. bytes.HasSuffix(b, suffix) 判断字节切片b是否以suffix结尾
• 4. bytes.Index(b, subslice) 返回subslice在b中第一次出现的位置，如果没有返回-1
• 5. bytes.LastIndex(b, subslice) 返回subslice在b中最后一次出现的位置，如果没有返回-1
• 6. bytes.Replace(b, old, new, n) 将b中的old替换为new，n表示替换的次数，-1表示全部替换
• 7. bytes.ReplaceAll(b, old, new) 将b中的old替换为new，返回替换后的字节切片
• 8. bytes.Split(b, sep) 将b按照sep分割成一个字节切片切片
• 9. bytes.Join(s [][]byte, sep []byte) 将字节切片切片s中的元素用sep连接成一个字节切片
• 10. bytes.Trim(b, cutset) 去掉b两端的cutset中的字节
• 11. bytes.TrimLeft(b, cutset) 去掉b左端的cutset中的字节
• 12. bytes.TrimRight(b, cutset) 去掉b右端的cutset中的字节
• 13. bytes.TrimSpace(b) 去掉b两端的空白字节
• 14. bytes.Equal(a, b) 判断字节切片a和b是否相等
• 15. bytes.EqualFold(a, b) 判断字节切片a和b是否相等，忽略大小写
• 16. bytes.Count(b, subslice) 返回subslice在b中出现的次数
• 17. bytes.Duplicate(b) 返回b的一个副本
• 18. bytes.NewBuffer(buf []byte) 返回一个Buffer，用于读写字节切片
• 19. bytes.NewBufferString(s string) 返回一个Buffer，用于读写字符串
• 20. bytes.NewReader(b []byte) 返回一个Reader，用于读取字节切片
• 21. bytes.SplitN(b, sep []byte, n int) 将b按照sep分割成n个子字节切片，最后一个子字节切片包含剩余的部分
• 22. bytes.SplitAfter(b, sep []byte) 将b按照sep分割成一个字节切片切片，sep作为切分结果的一部分
• 23. bytes.SplitAfterN(b, sep []byte, n int) 将b按照sep分割成n个子字节切片，sep作为切分结果的一部分，最后一个子字节切片包含剩余的部分
• 24. bytes.TrimPrefix(b, prefix []byte) 去掉b开头的prefix
• 25. bytes.TrimSuffix(b, suffix []byte) 去掉b结尾的suffix
• 26. bytes.HasAny(b, chars string) 判断b中是否包含chars中的任意字节
• 27. bytes.IndexAny(b, chars string) 返回b中第一个出现chars中任意字节的位置，如果没有返回-1
• 28. bytes.LastIndexAny(b, chars string) 返回b中最后一个出现chars中任意字节的位置，如果没有返回-1
• 29. bytes.TrimFunc(b []byte, f func(rune) bool) 去掉b两端满足f函数条件的字节
• 30. bytes.TrimLeftFunc(b []byte, f func(rune) bool) 去掉b左端满足f函数条件的字节
• 31. bytes.TrimRightFunc(b []byte, f func(rune) bool) 去掉b右端满足f函数条件的字节
• 32. bytes.FieldsFunc(b []byte, f func(rune) bool) 将b按照满足f函数条件的字节分割成一个字节切片切片
• 33. bytes.ToUpper(b []byte) 将b中的字母转换为大写
• 34. bytes.ToLower(b []byte) 将b中的字母转换为小写
• 35. bytes.ToTitle(b []byte) 将b中的每个单词的首字母转换为大写
• 36. bytes.ToTitleSpecial(caser unicode.SpecialCase, b []byte) 根据指定的caser将b中的字母转换为标题格式
• 37. bytes.ToLowerSpecial(caser unicode.SpecialCase, b []byte) 根据指定的caser将b中的字母转换为小写
• 38. bytes.ToUpperSpecial(caser unicode.SpecialCase, b []byte) 根据指定的caser将b中的字母转换为大写

strconv 包中常用函数：

• 1. strconv.Atoi(s string) 将字符串s转换为整数，返回转换后的整数和一个错误对象
• 2. strconv.Itoa(i int) 将整数i转换为字符串
• 3. strconv.ParseBool(s string) 将字符串s转换为布尔值，返回转换后的布尔值和一个错误对象
• 4. strconv.ParseFloat(s string, bitSize int) 将字符串s转换为浮点数，bitSize指定返回浮点数的位数（32或64），返回转换后的浮点数和一个错误对象
• 5. strconv.ParseInt(s string, base int, bitSize int) 将字符串s转换为整数，base指定数字的进制（2到36），bitSize指定

返回转换后的整数和一个错误对象

• 6. strconv.ParseUint(s string, base int, bitSize int) 将字符串s转换为无符号整数，base指定数字的进制（2到36），bitSize指定返回无符号整数的位数（0、8、16、32或64），返回转换后的无符号整数和一个错误对象
• 7. strconv.FormatBool(b bool) 将布尔值b转换为字符串
• 8. strconv.FormatFloat(f float64, fmt byte, prec int, bitSize int) 将浮点数f转换为字符串，fmt指定格式（'b'、'e'、'E'、'f'、'F'、'g'、'G'），prec指定小数点后的位数，bitSize指定f的位数（32或64），返回转换后的字符串
• 9. strconv.FormatInt(i int64, base int) 将整数i转换为字符串，base指定数字的进制（2到36），返回转换后的字符串
• 10. strconv.FormatUint(i uint64, base int) 将无符号整数i转换为字符串，base指定数字的进制（2到36），返回转换后的字符串
• 11. strconv.Quote(s string) 将字符串s转换为一个双引号包裹的字符串，并对其中的特殊字符进行转义
• 12. strconv.QuoteToASCII(s string) 将字符串s转换为一个双引号包裹的字符串，并将其中的非ASCII字符转换为转义序列
• 13. strconv.QuoteToGraphic(s string) 将字符串s转换为一个双引号包裹的字符串，并将其中的非图形字符转换为转义序列
• 14. strconv.QuoteRune(r rune) 将rune类型的字符r转换为一个单引号包裹的字符，并对其中的特殊字符进行转义
• 15. strconv.QuoteRuneToASCII(r rune) 将rune类型的字符r转换为一个单引号包裹的字符，并将其中的非ASCII字符转换为转义序列
• 16. strconv.QuoteRuneToGraphic(r rune) 将rune类型的字符r转换为一个单引号包裹的字符，并将其中的非图形字符转换为转义序列
• 17. strconv.Unquote(s string) 将一个双引号包裹的字符串s转换为普通字符串，并对其中的转义序列进行解析，返回转换后的字符串和一个错误对象
• 18. strconv.UnquoteChar(s string, quote byte) 将s中的第一个字符解析为一个字符，quote指定s中使用的引号类型（'或"），返回解析后的字符、解析后剩余的字符串和一个错误对象
• 19. strconv.IsPrint(r rune) 判断字符r是否是可打印字符
• 20. strconv.IsGraphic(r rune) 判断字符r是否是图形字符
• 21. strconv.IsDigit(r rune) 判断字符r是否是数字字符
• 22. strconv.IsLetter(r rune) 判断字符r是否是字母字符
• 23. strconv.IsLower(r rune) 判断字符r是否是小写字母
• 24. strconv.IsUpper(r rune) 判断字符r是否是大写字母
• 25. strconv.IsSpace(r rune) 判断字符r是否是空白字符
• 26. strconv.IsPunct(r rune) 判断字符r是否是标点符号字符
• 27. strconv.IsControl(r rune) 判断字符r是否是控制字符
• 28. strconv.IsNumber(r rune) 判断字符r是否是数字字符（包括Unicode中的数字）
• 29. strconv.IsOneOf(chars string, r rune) 判断字符r是否在chars中
• 30. strconv.IsValidRune(r rune) 判断字符r是否是一个有效的Unicode码点