Skip to main content

Std Strings

好的，以下是每个函数的签名、解释和一个简单的示例代码：

1. Clone(s string) string​

解释：返回字符串 s 的一个副本。

package main

import (
	"fmt"
	"strings"
)

func main() {
	original := "Hello, World!"
	clone := strings.Clone(original)
	fmt.Println(clone) // 输出: Hello, World!
}

2. Compare(a, b string) int​

解释：比较两个字符串 a 和 b，返回值：

  • 0：如果 a == b
  • -1：如果 a < b
  • 1：如果 a > b
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Compare("apple", "banana")) // 输出: -1
	fmt.Println(strings.Compare("banana", "apple")) // 输出: 1
	fmt.Println(strings.Compare("apple", "apple"))  // 输出: 0
}

3. Contains(s, substr string) bool​

解释：判断字符串 s 是否包含子字符串 substr。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Contains("Hello, World!", "World")) // 输出: true
	fmt.Println(strings.Contains("Hello, World!", "world")) // 输出: false
}

4. ContainsAny(s, chars string) bool​

解释：判断字符串 s 是否包含 chars 中的任意一个字符。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ContainsAny("Hello, World!", "aeiou")) // 输出: true
	fmt.Println(strings.ContainsAny("Hello, World!", "xyz"))   // 输出: false
}

5. ContainsFunc(s string, f func(rune) bool) bool​

解释：判断字符串 s 是否包含满足函数 f 的任意字符。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isDigit := func(r rune) bool {
		return unicode.IsDigit(r)
	}
	fmt.Println(strings.ContainsFunc("Hello123", isDigit)) // 输出: true
	fmt.Println(strings.ContainsFunc("Hello", isDigit))    // 输出: false
}

6. ContainsRune(s string, r rune) bool​

解释：判断字符串 s 是否包含指定的 rune。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ContainsRune("Hello, 世界", '世')) // 输出: true
	fmt.Println(strings.ContainsRune("Hello, 世界", '界')) // 输出: true
	fmt.Println(strings.ContainsRune("Hello, 世界", 'a'))  // 输出: false
}

7. Count(s, substr string) int​

解释：返回子字符串 substr 在字符串 s 中出现的次数。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Count("Hello, Hello, Hello!", "Hello")) // 输出: 3
	fmt.Println(strings.Count("Hello, Hello, Hello!", "World")) // 输出: 0
}

8. Cut(s, sep string) (before, after string, found bool)​

解释：从字符串 s 中查找分隔符 sep，返回分隔符前后的字符串以及是否找到分隔符。

package main

import (
	"fmt"
	"strings"
)

func main() {
	before, after, found := strings.Cut("Hello, World!", ", ")
	fmt.Println(before, after, found) // 输出: Hello World! true

	before, after, found = strings.Cut("Hello, World!", "XYZ")
	fmt.Println(before, after, found) // 输出: Hello, World!  false
}

9. CutPrefix(s, prefix string) (after string, found bool)​

解释：如果字符串 s 以 prefix 开头，返回去掉前缀后的字符串和 true，否则返回原字符串和 false。

package main

import (
	"fmt"
	"strings"
)

func main() {
	after, found := strings.CutPrefix("Hello, World!", "Hello")
	fmt.Println(after, found) // 输出: , World! true

	after, found = strings.CutPrefix("Hello, World!", "World")
	fmt.Println(after, found) // 输出: Hello, World! false
}

10. CutSuffix(s, suffix string) (before string, found bool)​

解释：如果字符串 s 以 suffix 结尾，返回去掉后缀后的字符串和 true，否则返回原字符串和 false。

package main

import (
	"fmt"
	"strings"
)

func main() {
	before, found := strings.CutSuffix("Hello, World!", "World!")
	fmt.Println(before, found) // 输出: Hello,  true

	before, found = strings.CutSuffix("Hello, World!", "Hello")
	fmt.Println(before, found) // 输出: Hello, World! false
}

11. EqualFold(s, t string) bool​

解释：判断两个字符串在不区分大小写的情况下是否相等。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.EqualFold("GoLang", "golang")) // 输出: true
	fmt.Println(strings.EqualFold("GoLang", "Python")) // 输出: false
}

12. Fields(s string) []string​

解释：将字符串 s 按空白字符分割成若干子字符串，并返回这些子字符串的切片。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Fields("Hello World! This is Go.")) // 输出: [Hello World! This is Go.]
}

13. FieldsFunc(s string, f func(rune) bool) []string​

解释：将字符串 s 按满足函数 f 的字符分割成若干子字符串，并返回这些子字符串的切片。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isSeparator := func(r rune) bool {
		return unicode.IsPunct(r) || unicode.IsSpace(r)
	}
	fmt.Println(strings.FieldsFunc("Hello, World! This is Go.", isSeparator)) // 输出: [Hello World This is Go]
}

14. HasPrefix(s, prefix string) bool​

解释：判断字符串 s 是否以 prefix 开头。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.HasPrefix("Hello, World!", "Hello")) // 输出: true
	fmt.Println(strings.HasPrefix("Hello, World!", "World")) // 输出: false
}

15. HasSuffix(s, suffix string) bool​

解释：判断字符串 s 是否以 suffix 结尾。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.HasSuffix("Hello, World!", "World!")) // 输出: true
	fmt.Println(strings.HasSuffix("Hello, World!", "Hello"))  // 输出: false
}

16. Index(s, substr string) int​

解释：返回子字符串 substr 在字符串 s 中第一次出现的位置索引，如果未找到则返回 -1。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Index("Hello, World!", "World")) // 输出: 7
	fmt.Println(strings.Index("Hello, World!", "world")) // 输出: -1
}

17. IndexAny(s, chars string) int​

解释：返回 chars 中的任意字符在字符串 s 中第一次出现的位置索引，如果未找到则返回 -1。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.IndexAny("Hello, World!", "aeiou")) // 输出: 1
	fmt.Println(strings.IndexAny("Hello, World!", "xyz"))   // 输出: -1
}

18. IndexByte(s string, c byte) int​

解释：返回字节 c 在字符串 s 中第一次出现的位置索引，如果未找到则返回 -1。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.IndexByte("Hello, World!", 'o')) // 输出: 4
	fmt.Println(strings.IndexByte("Hello, World!", 'x')) // 输出: -1
}

19. IndexFunc(s string, f func(rune) bool) int​

解释：返回满足函数 f 的第一个字符在字符串 s 中的位置索引，如果未找到则返回 -1。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isDigit := func(r rune) bool {
		return unicode.IsDigit(r)
	}
	fmt.Println(strings.IndexFunc("Hello123", isDigit)) // 输出: 5
	fmt.Println(strings.IndexFunc("Hello", isDigit))    // 输出: -1
}

20. IndexRune(s string, r rune) int​

解释：返回 rune 在字符串 s 中第一次出现的位置索引，如果未找到则返回 -1。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.IndexRune("Hello, 世界", '世')) // 输出: 7
	fmt.Println(strings.IndexRune("Hello, 世界", '界')) // 输出: 10
	fmt.Println(strings.IndexRune("Hello, 世界", 'a'))  // 输出: -1
}

21. Join(elems []string, sep string) string​

解释：将字符串切片 elems 用分隔符 sep 连接成一个字符串。

package main

import (
	"fmt"
	"strings"
)

func main() {
	elems := []string{"Hello", "World", "Go"}
	fmt.Println(strings.Join(elems, ", ")) // 输出: Hello, World, Go
}

22. LastIndex(s, substr string) int​

解释：返回子字符串 substr 在字符串 s 中最后一次出现的位置索引，如果未找到则返回 -1。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.LastIndex("Hello, Hello, Hello!", "Hello")) // 输出: 14
	fmt.Println(strings.LastIndex("Hello, Hello, Hello!", "World")) // 输出: -1
}

23. LastIndexAny(s, chars string) int​

解释：返回 chars 中的任意字符在字符串 s 中最后一次出现的位置索引，如果未找到则返回 -1。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.LastIndexAny("Hello, World!", "aeiou")) // 输出: 8
	fmt.Println(strings.LastIndexAny("Hello, World!", "xyz"))   // 输出: -1
}

24. LastIndexByte(s string, c byte) int​

解释：返回字节 c 在字符串 s 中最后一次出现的位置索引，如果未找到则返回 -1。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.LastIndexByte("Hello, World!", 'o')) // 输出: 8
	fmt.Println(strings.LastIndexByte("Hello, World!", 'x')) // 输出: -1
}

25. LastIndexFunc(s string, f func(rune) bool) int​

解释：返回满足函数 f 的最后一个字符在字符串 s 中的位置索引，如果未找到则返回 -1。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isDigit := func(r rune) bool {
		return unicode.IsDigit(r)
	}
	fmt.Println(strings.LastIndexFunc("Hello123", isDigit)) // 输出: 7
	fmt.Println(strings.LastIndexFunc("Hello", isDigit))    // 输出: -1
}

26. Map(mapping func(rune) rune, s string) string​

解释：返回一个新的字符串，其中每个字符都是通过函数 mapping 处理后的结果。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	toUpper := func(r rune) rune {
		return unicode.ToUpper(r)
	}
	fmt.Println(strings.Map(toUpper, "Hello, World!")) // 输出: HELLO, WORLD!
}

27. Repeat(s string, count int) string​

解释：返回一个新的字符串，重复字符串 s count 次。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Repeat("Go", 3)) // 输出: GoGoGo
}

28. Replace(s, old, new string, n int) string​

解释：返回一个新的字符串，其中 s 中的前 n 个 old 被替换为 new。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Replace("Hello, Hello, Hello!", "Hello", "Hi", 2)) // 输出: Hi, Hi, Hello!
}

29. ReplaceAll(s, old, new string) string​

解释：返回一个新的字符串，其中 s 中的所有 old 都被替换为 new。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ReplaceAll("Hello, Hello, Hello!", "Hello", "Hi")) // 输出: Hi, Hi, Hi!
}

30. Split(s, sep string) []string​

解释：将字符串 s 按分隔符 sep 分割成若干子字符串，并返回这些子字符串的切片。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Split("a,b,c,d", ",")) // 输出: [a b c d]
}

31. SplitAfter(s, sep string) []string​

解释：将字符串 s 按分隔符 sep 分割成若干子字符串，并在每个子字符串后保留分隔符。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.SplitAfter("a,b,c,d", ",")) // 输出: [a, b, c, d]
}

32. SplitAfterN(s, sep string, n int) []string​

解释：将字符串 s 按分隔符 sep 分割成最多 n 个子字符串，并在每个子字符串后保留分隔符。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.SplitAfterN("a,b,c,d", ",", 2)) // 输出: [a, b,c,d]
}

33. SplitN(s, sep string, n int) []string​

解释：将字符串 s 按分隔符 sep 分割成最多 n 个子字符串。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.SplitN("a,b,c,d", ",", 2)) // 输出: [a b,c,d]
}

34. Title(s string) string (DEPRECATED)​

解释：返回一个字符串，其中每个单词的首字母都被转换为大写。已弃用。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Title("hello world")) // 输出: Hello World
}

35. ToLower(s string) string​

解释：返回一个新的字符串，其中 s 中的所有字符都被转换为小写。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToLower("Hello, World!")) // 输出: hello, world!
}

36. ToLowerSpecial(c unicode.SpecialCase, s string) string​

解释：返回一个新的字符串，其中 s 中的所有字符都根据 c 被转换为小写。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "İstanbul")) // 输出: istanbul
}

37. ToTitle(s string) string​

解释：返回一个新的字符串，其中 s 中的所有字符都被转换为标题格式。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToTitle("hello, world!")) // 输出: HELLO, WORLD!
}

38. ToTitleSpecial(c unicode.SpecialCase, s string) string​

解释：返回一个新的字符串，其中 s 中的所有字符都根据 c 被转换为标题格式。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	fmt.Println(strings.ToTitleSpecial(unicode.TurkishCase, "istanbul")) // 输出: İSTANBUL
}

39. ToUpper(s string) string​

解释：返回一个新的字符串，其中 s 中的所有字符都被转换为大写。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToUpper("hello, world!")) // 输出: HELLO, WORLD!
}

40. ToUpperSpecial(c unicode.SpecialCase, s string) string​

解释：返回一个新的字符串，其中 s 中的所有字符都根据 c 被转换为大写。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	fmt
```go
	fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "istanbul")) // 输出: İSTANBUL
}

41. Trim(s string, cutset string) string​

解释：返回一个新的字符串，其中 s 的前后所有属于 cutset 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Trim("!!!Hello, World!!!", "!")) // 输出: Hello, World
}

42. TrimFunc(s string, f func(rune) bool) string​

解释：返回一个新的字符串，其中 s 的前后所有满足函数 f 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isPunctOrSpace := func(r rune) bool {
		return unicode.IsPunct(r) || unicode.IsSpace(r)
	}
	fmt.Println(strings.TrimFunc("!!!Hello, World!!!", isPunctOrSpace)) // 输出: Hello, World
}

43. TrimLeft(s string, cutset string) string​

解释：返回一个新的字符串，其中 s 的左侧所有属于 cutset 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimLeft("!!!Hello, World!!!", "!")) // 输出: Hello, World!!!
}

44. TrimLeftFunc(s string, f func(rune) bool) string​

解释：返回一个新的字符串，其中 s 的左侧所有满足函数 f 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isPunctOrSpace := func(r rune) bool {
		return unicode.IsPunct(r) || unicode.IsSpace(r)
	}
	fmt.Println(strings.TrimLeftFunc("!!!Hello, World!!!", isPunctOrSpace)) // 输出: Hello, World!!!
}

45. TrimPrefix(s, prefix string) string​

解释：如果字符串 s 以 prefix 开头，返回去掉前缀后的字符串，否则返回原字符串。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimPrefix("Hello, World!", "Hello")) // 输出: , World!
	fmt.Println(strings.TrimPrefix("Hello, World!", "World")) // 输出: Hello, World!
}

46. TrimRight(s string, cutset string) string​

解释：返回一个新的字符串，其中 s 的右侧所有属于 cutset 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimRight("!!!Hello, World!!!", "!")) // 输出: !!!Hello, World
}

47. TrimRightFunc(s string, f func(rune) bool) string​

解释：返回一个新的字符串，其中 s 的右侧所有满足函数 f 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isPunctOrSpace := func(r rune) bool {
		return unicode.IsPunct(r) || unicode.IsSpace(r)
	}
	fmt.Println(strings.TrimRightFunc("!!!Hello, World!!!", isPunctOrSpace)) // 输出: !!!Hello, World
}

48. TrimSpace(s string) string​

解释：返回一个新的字符串，其中 s 的前后所有空白字符都被去掉。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimSpace("   Hello, World!   ")) // 输出: Hello, World!
}

49. TrimSuffix(s, suffix string) string​

解释：如果字符串 s 以 suffix 结尾，返回去掉后缀后的字符串，否则返回原字符串。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimSuffix("Hello, World!", "World!")) // 输出: Hello,
	fmt.Println(strings.TrimSuffix("Hello, World!", "Hello"))  // 输出: Hello, World!
}

50. NewReplacer(oldnew ...string) *Replacer​

解释：返回一个新的 Replacer，它可以将多个 old 字符串替换为对应的 new 字符串。

package main

import (
	"fmt"
	"strings"
)

func main() {
	r := strings.NewReplacer("Hello", "Hi", "World", "Earth")
	fmt.Println(r.Replace("Hello, World!")) // 输出: Hi, Earth!
}

51. Builder​

解释：strings.Builder 是一个用于高效构建字符串的类型。

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	b.WriteString("Hello")
	b.WriteString(", ")
	b.WriteString("World!")
	fmt.Println(b.String()) // 输出: Hello, World!
}

52. Reader​

解释：strings.Reader 是一个用于读取字符串的类型。

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	r := strings.NewReader("Hello, World!")
	buf := make([]byte, 5)
	for {
		n, err := r.Read(buf)
		if err == io.EOF {
			break
		}
		fmt.Printf("%s", buf[:n]) // 输出: Hello, World!
	}
}
fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "istanbul")) // 输出: İSTANBUL
}

41. Trim(s string, cutset string) string​

解释：返回一个新的字符串，其中 s 的前后所有属于 cutset 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Trim("!!!Hello, World!!!", "!")) // 输出: Hello, World
}

42. TrimFunc(s string, f func(rune) bool) string​

解释：返回一个新的字符串，其中 s 的前后所有满足函数 f 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isPunctOrSpace := func(r rune) bool {
		return unicode.IsPunct(r) || unicode.IsSpace(r)
	}
	fmt.Println(strings.TrimFunc("!!!Hello, World!!!", isPunctOrSpace)) // 输出: Hello, World
}

43. TrimLeft(s string, cutset string) string​

解释：返回一个新的字符串，其中 s 的左侧所有属于 cutset 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimLeft("!!!Hello, World!!!", "!")) // 输出: Hello, World!!!
}

44. TrimLeftFunc(s string, f func(rune) bool) string​

解释：返回一个新的字符串，其中 s 的左侧所有满足函数 f 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isPunctOrSpace := func(r rune) bool {
		return unicode.IsPunct(r) || unicode.IsSpace(r)
	}
	fmt.Println(strings.TrimLeftFunc("!!!Hello, World!!!", isPunctOrSpace)) // 输出: Hello, World!!!
}

45. TrimPrefix(s, prefix string) string​

解释：如果字符串 s 以 prefix 开头，返回去掉前缀后的字符串，否则返回原字符串。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimPrefix("Hello, World!", "Hello")) // 输出: , World!
	fmt.Println(strings.TrimPrefix("Hello, World!", "World")) // 输出: Hello, World!
}

46. TrimRight(s string, cutset string) string​

解释：返回一个新的字符串，其中 s 的右侧所有属于 cutset 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimRight("!!!Hello, World!!!", "!")) // 输出: !!!Hello, World
}

47. TrimRightFunc(s string, f func(rune) bool) string​

解释：返回一个新的字符串，其中 s 的右侧所有满足函数 f 的字符都被去掉。

package main

import (
	"fmt"
	"strings"
	"unicode"
)

func main() {
	isPunctOrSpace := func(r rune) bool {
		return unicode.IsPunct(r) || unicode.IsSpace(r)
	}
	fmt.Println(strings.TrimRightFunc("!!!Hello, World!!!", isPunctOrSpace)) // 输出: !!!Hello, World
}

48. TrimSpace(s string) string​

解释：返回一个新的字符串，其中 s 的前后所有空白字符都被去掉。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimSpace("   Hello, World!   ")) // 输出: Hello, World!
}

49. TrimSuffix(s, suffix string) string​

解释：如果字符串 s 以 suffix 结尾，返回去掉后缀后的字符串，否则返回原字符串。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimSuffix("Hello, World!", "World!")) // 输出: Hello,
	fmt.Println(strings.TrimSuffix("Hello, World!", "Hello"))  // 输出: Hello, World!
}

50. NewReplacer(oldnew ...string) *Replacer​

解释：返回一个新的 Replacer，它可以将多个 old 字符串替换为对应的 new 字符串。

package main

import (
	"fmt"
	"strings"
)

func main() {
	r := strings.NewReplacer("Hello", "Hi", "World", "Earth")
	fmt.Println(r.Replace("Hello, World!")) // 输出: Hi, Earth!
}

51. Builder​

解释：strings.Builder 是一个用于高效构建字符串的类型。

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	b.WriteString("Hello")
	b.WriteString(", ")
	b.WriteString("World!")
	fmt.Println(b.String()) // 输出: Hello, World!
}

52. Reader​

解释：strings.Reader 是一个用于读取字符串的类型。

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	r := strings.NewReader("Hello, World!")
	buf := make([]byte, 5)
	for {
		n, err := r.Read(buf)
		if err == io.EOF {
			break
		}
		fmt.Printf("%s", buf[:n]) // 输出: Hello, World!
	}
}

这些示例展示了 Go 语言 strings 包中的各种函数及其用法。希望这些示例对你理解和使用 strings 包有所帮助！如果你有其他问题或需要更详细的解释，请随时告诉我。

strings.Builder vs strings.Reader​

strings.Builder 和 strings.Reader 是 Go 语言标准库 strings 包中的两个不同的类型，它们用于不同的目的。下面是它们的详细对比：

strings.Builder​

strings.Builder 是一个用于高效构建和拼接字符串的类型。它通过内部缓冲区管理字符串的拼接，避免了频繁的内存分配和复制操作。

主要特性​

  1. 高效拼接：通过内部缓冲区管理，减少内存分配和复制。
  2. 多种写入方法：提供了多种写入方法，如 WriteString、WriteByte、WriteRune 等。
  3. 获取结果：通过 String 方法获取最终拼接的字符串。
  4. 重置：可以通过 Reset 方法重置 Builder，以便重复使用。

示例代码​

package main

import (
	"fmt"
	"strings"
)

func main() {
	var builder strings.Builder

	// 写入字符串
	builder.WriteString("Hello, ")
	builder.WriteString("World!")

	// 获取最终字符串
	result := builder.String()
	fmt.Println(result) // Hello, World!
}

strings.Reader​

strings.Reader 是一个用于从字符串中读取数据的类型。它实现了多个 io 接口，如 io.Reader、io.ReaderAt、io.Seeker、io.WriterTo、io.ByteScanner 和 io.RuneScanner。

主要特性​

  1. 读取字符串：可以从字符串中读取数据，类似于从文件或网络连接中读取数据。
  2. 多种读取方法：实现了多个 io 接口，支持多种读取操作。
  3. 位置管理：可以通过 Seek 方法管理读取位置。

示例代码​

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	// 创建一个 strings.Reader
	r := strings.NewReader("Hello, World!")

	// 创建一个缓冲区
	buf := make([]byte, 5)

	// 从 strings.Reader 中读取数据
	n, err := r.Read(buf)
	if err != nil && err != io.EOF {
		fmt.Println("Error:", err)
		return
	}

	fmt.Printf("Read %d bytes: %s\n", n, string(buf[:n]))

	// 使用 Seek 方法将读取位置移动到开头
	r.Seek(0, io.SeekStart)

	// 再次读取数据
	n, err = r.Read(buf)
	if err != nil && err != io.EOF {
		fmt.Println("Error:", err)
		return
	}

	fmt.Printf("Read %d bytes: %s\n", n, string(buf[:n]))
}

对比总结​

  • 用途：

    • strings.Builder 用于高效地构建和拼接字符串。
    • strings.Reader 用于从字符串中读取数据，类似于从文件或网络连接中读取数据。

  • 主要操作：

    • strings.Builder 提供写入操作，如 WriteString、WriteByte、WriteRune 等。
    • strings.Reader 提供读取操作，如 Read、ReadAt、Seek 等。

  • 接口实现：

    • strings.Builder 没有实现标准的 io 接口。
    • strings.Reader 实现了多个 io 接口，如 io.Reader、io.ReaderAt、io.Seeker 等。

  • 性能：

    • strings.Builder 通过内部缓冲区管理拼接操作，性能较高，适用于频繁的字符串拼接操作。
    • strings.Reader 适用于从字符串中读取数据，尤其在需要实现 io.Reader 接口的场景中非常有用。

根据具体需求选择合适的类型，如果需要高效地构建字符串，使用 strings.Builder；如果需要从字符串中读取数据，使用 strings.Reader。