Go标准库字符串常用函数大全

前言

Go语言标准库提供了丰富的字符串处理函数，这些函数可以帮助开发者高效地处理字符串数据。以下是Go标准库中常用字符串处理函数的介绍及代码示例，我将列举出30个以上函数中的一部分重要和常用函数：

1. 字符串长度

• 函数：len(str)
• 描述：返回字符串的长度（以字节为单位，对于UTF-8编码的字符串，中文字符占3个字节）。
• 示例：

  str := "Hello, 世界!"
  fmt.Println(len(str)) // 输出：13（包含中英文）
  

2. 字符串遍历

• 函数：使用for-range循环或[]rune(str)
• 描述：遍历字符串中的每个字符（包括中文字符）。
• 示例：

  str := "Hello, 世界!"
  for _, c := range str {
      fmt.Printf("%c\n", c)
  }
  // 或者使用rune遍历中文字符
  r := []rune(str)
  for _, rc := range r {
      fmt.Printf("%c\n", rc)
  }
  

3. 字符串转整数

• 函数：strconv.Atoi(s string) (int, error)
• 描述：将字符串转换为整数。如果转换失败，返回错误。
• 示例：

  str := "123"
  num, err := strconv.Atoi(str)
  if err != nil {
      fmt.Println("转换错误:", err)
  } else {
      fmt.Println("转换后的整数:", num)
  }
  

4. 整数转字符串

• 函数：strconv.Itoa(i int) string
• 描述：将整数转换为字符串。
• 示例：

  num := 123
  str := strconv.Itoa(num)
  fmt.Println("转换后的字符串:", str)
  

5. 字符串转byte切片

• 函数：[]byte(str)
• 描述：将字符串转换为byte切片。
• 示例：

  str := "Hello"
  bytes := []byte(str)
  fmt.Println(bytes) // 输出：[]byte("Hello")
  

6. byte切片转字符串

• 函数：string([]byte{...})
• 描述：将byte切片转换为字符串。
• 示例：

  bytes := []byte{72, 101, 108, 108, 111}
  str := string(bytes)
  fmt.Println(str) // 输出：Hello
  

7. 字符串包含

• 函数：strings.Contains(s, substr string) bool
• 描述：检查字符串s是否包含子串substr。
• 示例：

  str := "Hello, world!"
  fmt.Println(strings.Contains(str, "world")) // 输出：true
  

8. 字符串计数

• 函数：strings.Count(s, substr string) int
• 描述：统计字符串s中子串substr出现的次数。
• 示例：

  str := "banana"
  fmt.Println(strings.Count(str, "a")) // 输出：3
  

9. 字符串比较（不区分大小写）

• 函数：strings.EqualFold(s, t string) bool
• 描述：比较两个字符串s和t，不区分大小写。
• 示例：

  str1 := "Hello"
  str2 := "hello"
  fmt.Println(strings.EqualFold(str1, str2)) // 输出：true
  

10. 子串位置（首次出现）

• 函数：strings.Index(s, substr string) int
• 描述：返回子串substr在字符串s中首次出现的位置索引，未找到时返回-1。
• 示例：

  str := "Hello, world!"
  fmt.Println(strings.Index(str, "world")) // 输出：7
  

11. 子串位置（最后一次出现）

• 函数：strings.LastIndex(s, substr string) int
• 描述：返回子串substr在字符串s中最后一次出现的位置索引，未找到时返回-1。
• 示例：

  str := "Hello, world! World"
  fmt.Println(strings.LastIndex(str, "world")) // 输出：13
  

12. 字符串替换

• 函数：strings.Replace(s, old, new string, n int) string
• 描述：在字符串s中将old替换为new，n指定替换次数，n=-1时替换所有。
• 示例：

  str := "Hello, world!"
  fmt.Println(strings.Replace(str, "world", "Go", 1)) // 输出：Hello, Go!
  fmt.Println(strings.Replace(str, "o", "O", -1))     // 输出：HellO, wOrld!
  

13. 字符串分割

• 函数：strings.Split(s, sep string) []string
• 描述：使用sep作为分隔符，将字符串s分割成多个子串，并返回这些子串的切片。
• 示例：

  str := "apple,banana,cherry"
  fmt.Println(strings.Split(str, ",")) // 输出：[]string{"apple", "banana", "cherry"}
  

14. 字符串连接

• 函数：strings.Join(a []string, sep string) string
• 描述：使用sep作为分隔符，将字符串切片a中的元素连接成一个字符串。
• 示例：

  a := []string{"Hello", "world", "!"}
  fmt.Println(strings.Join(a, " ")) // 输出：Hello world !
  

15. 字符串大小写转换

• 函数：strings.ToLower(s string) string 和 strings.ToUpper(s string) string
• 描述：将字符串s转换为小写或大写。
• 示例：

  str := "Hello, World!"
  fmt.Println(strings.ToLower(str)) // 输出：hello, world!
  fmt.Println(strings.ToUpper(str)) // 输出：HELLO, WORLD!
  

16. 去除字符串首尾空格

• 函数：strings.TrimSpace(s string) string
• 描述：去除字符串s首尾的空白字符（包括空格、换行符等）。
• 示例：

  str := "   Hello, World!   "
  fmt.Println(strings.TrimSpace(str)) // 输出：Hello, World!
  

17. 去除字符串首尾指定字符

• 函数：strings.Trim(s, cutset string) string
• 描述：去除字符串s首尾的cutset指定的字符集合中的字符。
• 示例：

  str := "!!!Hello, World!!!"
  fmt.Println(strings.Trim(str, "!")) // 输出：Hello, World
  

18. 去除字符串左侧指定字符

• 函数：strings.TrimLeft(s, cutset string) string
• 描述：去除字符串s左侧的cutset指定的字符集合中的字符。
• 示例：

  str := "!!!Hello, World!!!"
  fmt.Println(strings.TrimLeft(str, "!")) // 输出：Hello, World!!!
  

19. 去除字符串右侧指定字符

• 函数：strings.TrimRight(s, cutset string) string
• 描述：去除字符串s右侧的cutset指定的字符集合中的字符。
• 示例：

  str := "!!!Hello, World!!!"
  fmt.Println(strings.TrimRight(str, "!")) // 输出：!!!Hello, World
  

20. 判断字符串是否以指定前缀开始

• 函数：strings.HasPrefix(s, prefix string) bool
• 描述：判断字符串s是否以prefix指定的前缀开始。
• 示例：

  str := "Hello, world!"
  fmt.Println(strings.HasPrefix(str, "Hello")) // 输出：true
  fmt.Println(strings.HasPrefix(str, "hello")) // 输出：false
  

21. 判断字符串是否以指定后缀结束

• 函数：strings.HasSuffix(s, suffix string) bool
• 描述：判断字符串s是否以suffix指定的后缀结束。
• 示例：

  str := "Hello, world!"
  fmt.Println(strings.HasSuffix(str, "world!")) // 输出：true
  fmt.Println(strings.HasSuffix(str, "hello"))  // 输出：false
  

22. 字符串重复

• 函数：strings.Repeat(s string, count int) string
• 描述：将字符串s重复count次，并返回结果字符串。
• 示例：

  str := "Go"
  fmt.Println(strings.Repeat(str, 3)) // 输出：GoGoGo
  

23. 字符串字段分割

• 函数：strings.Fields(s string) []string
• 描述：按照空白字符（如空格、换行符等）分割字符串s，并返回分割后的字段切片。
• 示例：

  str := "Hello world Go!"
  fmt.Println(strings.Fields(str)) // 输出：[Hello world Go!]
  // 注意：上面的输出可能看起来没有分割，但如果有多个空格或换行符等，会按空白分割
  strWithSpaces := "Hello    world    Go!"
  fmt.Println(strings.Fields(strWithSpaces)) // 输出：[Hello world Go!]
  

24. 字符串字段按指定分隔符分割

• 函数：strings.FieldsFunc(s string, f func(rune) bool) []string
• 描述：根据提供的函数f（该函数决定哪些字符是分隔符）来分割字符串s，并返回分割后的字段切片。
• 示例：

  str := "Hello,world;Go!"
  f := func(r rune) bool {
      return r == ',' || r == ';'
  }
  fmt.Println(strings.FieldsFunc(str, f)) // 输出：[Hello world Go!]
  

25. 字符串映射（替换每个满足条件的字符）

• 函数：虽然标准库中没有直接的字符串映射函数，但可以通过strings.Map或strings.NewReplacer来实现。

• strings.Map：func Map(mapping func(rune) rune, s string) string

• 描述：将字符串s中的每个字符通过mapping函数映射成新的字符，然后返回新的字符串。

• 示例：

  str := "Hello, world!"
  mapping := func(r rune) rune {
      if r >= 'a' && r <= 'z' {
          return r - 'a' + 'A'
      }
      return r
  }
  fmt.Println(strings.Map(mapping, str)) // 输出：HELLO, world!
  

• strings.NewReplacer：更适合替换字符串中的特定子串。

  replacer := strings.NewReplacer("world", "Go")
  str := "Hello, world!"
  fmt.Println(replacer.Replace(str)) // 输出：Hello, Go!
  

26. 字符串中字符的索引位置

• 函数：虽然标准库中没有直接返回所有字符索引的函数，但可以通过遍历字符串或使用strings.IndexRune找到特定字符的索引。
• strings.IndexRune：func IndexRune(s string, r rune) int
• 描述：返回字符r在字符串s中首次出现的位置索引，未找到时返回-1。
• 示例：

  str := "Hello, world!"
  fmt.Println(strings.IndexRune(str, 'w')) // 输出：7
  

27. 字符串的UTF-8编码与解码

• 函数：虽然Go标准库中的字符串总是以UTF-8编码，但处理字符串时可能需要手动编码或解码为rune切片。
• 编码：[]rune(str)
• 解码：string([]rune{...})

28. 字符串的格式化

• 函数：fmt.Sprintf(format string, a ...interface{}) string
• 描述：根据format参数生成格式化的字符串，并返回该字符串。
• 示例：

  name := "John"
  age := 30
  str := fmt.Sprintf("Name: %s, Age: %d", name, age)
  fmt.Println(str) // 输出：Name: John, Age: 30
  

29. 字符串的切片操作

• 操作：虽然字符串在Go中是不可变的，但可以使用切片语法来“获取”子字符串。
• 示例：

  str := "Hello, world!"
  subStr := str[7:12] // 获取索引7到12（不包括12）的子字符串
  fmt.Println(subStr) // 输出：world
  

30. 字符串的查找与替换（正则表达式）

• 函数：虽然标准库中的strings包不直接支持正则表达式，但regexp包提供了这一功能。
• 示例：

  import "regexp"
  
  str := "Hello, world! 123"
  re := regexp.MustCompile(`\d+`) // 匹配一个或多个数字
  newStr := re.ReplaceAllString(str, "XXX")
  fmt.Println(newStr) // 输出：Hello, world! XXX
  

总结

以上列出了Go标准库中一些常用的字符串处理函数和示例。请注意，这里只展示了部分函数，但Go的字符串处理能力远不止这些。其他的可以慢慢发掘，而上述函数，基本够日常我们开发使用。