golang --strings 下常用函数api

1. func Compare(a, b string) int {}

比较返回一个按字典顺序比较两个字符串的整数。如果a == b则结果为0，如果a <b则结果为-1，如果a> b则结果为+1。 此外：仅包含与包字节对称的比较。使用内置字符串比较运算符==，<，>等通常更清晰，速度更快。

fmt.Println（strings.Compare（“a”，“b”）） fmt.Println（strings.Compare（“a”，“a”）） fmt.Println（strings.Compare（“b”，“a”） ）

输出： -1 0 1 注意：使用大于等于小于同样可以得到同样的答案。

2. func Contains(s, substr string) bool {}

判断字符串substr是否在字符串s中，返回类型为布尔值。

fmt.Println(strings.ContainsAny("team", "i")) fmt.Println(strings.ContainsAny("failure", "i&k")) fmt.Println(strings.ContainsAny("failure", "")) fmt.Println(strings.ContainsAny("", ""))

输出： false true false false

3. func ContainsRune(s string, r rune) bool{}

将s转化为unicode编码，然后判断r是否在其中，返回值类型为bool值 //查找字符串是否包含特定的Unicode代码点。 //例如，小写字母“a”的代码点是97.

fmt.Println(strings.ContainsRune("aardvark", 97))

fmt.Println(strings.ContainsRune("timeout", 97))

输出： true false

4. func Count(s, substr string) int{}

统计字符串s中substr字符串的个数，返回值类型为×××。 如果substr是空字符串，则Count返回1 + s包含的个数

fmt.Println(strings.Count("cheese", "e"))

fmt.Println(strings.Count("five", "")) //在每个符文之前和之后

输出： 3 5

5. func EqualFold（s，t string）bool{}

不考虑大小写，判断字符串s、t是否相同，返回值类型为布尔值

fmt.Println(strings.EqualFold("Go", "go"))

输出： true

6. func Fields(s string) []string{}

按照空格进行切分，将字符串s切割成一个切片。返回值类型为切片类型

fmt.Printf("Fields are:%q", strings.Fields("foo bar baz"))

输出：

Fields are:["foo" "bar" "baz"]

7. func FieldsFunc(s string, f func(rune) bool) []string{}

FieldsFunc在每次运行满足f（c）的Unicode代码点c时拆分字符串s，并返回s的切片数组。如果s中的所有代码点满足f（c）或字符串为空，则返回空切片。FieldsFunc不保证它调用f（c）的顺序。如果f没有返回给定c的一致结果，则FieldsFunc可能会崩溃。

f := func(c rune) bool { return !unicode.IsLetter(c) && !unicode.IsNumber(c) } fmt.Printf("Fields is %q", strings.FieldsFunc("fool; bar2,baz3, ..", f))　

输出：Fields is ["fool" "bar2" "baz3"]

8. func HasPrefix(s, prefix string) bool{}

判断s字符串是否是以prefix字符串开头的，返回值类型为布尔值 注意：若prefix为空字符串，则为恒真

fmt.Println(strings.HasPrefix("Gopher", "Go")) fmt.Println(strings.HasPrefix("Gopher", "c")) fmt.Println(strings.HasPrefix("Gopher", ""))

Output: true false true

9. func HasSuffix(s, suffix string) bool{}

判断s字符串是否是以prefix字符串结束的，返回值类型为布尔值 注意：若prefix为空字符串，则为恒真

fmt.Println(strings.HasSuffix("Amigo", "go")) fmt.Println(strings.HasSuffix("Amigo", "o")) fmt.Println(strings.HasSuffix("Amigo", "Ami")) fmt.Println(strings.HasSuffix("Amigo", ""))

Output: true true false true

9. func Index(s, substr string) int{}

返回第一个s中包含substr 的字符的索引，若无则返回-1

fmt.Println(strings.Index("Amigo", "go")) fmt.Println(strings.Index("Amigo", "o")) fmt.Println(strings.Index("Amigo", "sdrg")) fmt.Println(strings.Index("Amigo", ""))

　　

Output: 3 4 -1 0

10. func IndexAny(s, chars string) int{}

先判断s与chars中是否有相同的元素，若有则返回相同元素在s中的第一个索引，若无，则返回-1

fmt.Println(strings.IndexAny("Amooigo", "om")) fmt.Println(strings.IndexAny("Amooigo", "o")) fmt.Println(strings.IndexAny("Amooigo", "sdrg")) fmt.Println(strings.IndexAny("Amooigo", ""))

　　

输出： 1 2 5 -1

11. func IndexByte(s string, c byte) int{}

IndexByte返回s中第一个c实例的索引，如果s中不存在c，则返回-1。

fmt.Println(strings.IndexByte("Amooigo", 'm')) fmt.Println(strings.IndexByte("Amooigo", 'o')) fmt.Println(strings.IndexByte("Amooigo", 's')) fmt.Println(strings.IndexByte("Amooigo", ' '))

输出： 1 2 -1 -1

12. func IndexFunc(s string, f func(rune) bool) int{}

IndexFunc将索引返回到满足f（c）的第一个Unicode代码点的s，如果没有，则返回-1。

f := func(c rune) bool { return unicode.Is(unicode.Han, c) } fmt.Println(strings.IndexFunc("Hello,world", f)) fmt.Println(strings.IndexFunc("Hello, 世界", f))　

输出： -1 7

13. func IndexRune(s string, r rune) int{}

IndexRune返回Unicode代码点r的第一个实例的索引，如果s中不存在符文，则返回-1。如果r是utf8.RuneError，则返回任何无效的UTF-8字节序列的第一个实例。

fmt.Println(strings.IndexRune("Hello,world", 'w')) fmt.Println(strings.IndexRune("Hello,世界！", '界'))

输出： 6 9

14. func Join(a []string, sep string) string{}

将切片按照sep进行连接，形成一个字符串

s := []string{"foo", "bar", "baz"} fmt.Println(strings.Join(s, "-"))

Output: foo-bar-baz

15. func LastIndex(s, substr string) int{}

返回字符串s包含substr最后的一个索引值，没有找到就返回-1

fmt.Println(strings.Index("go gopher", "go")) fmt.Println(strings.LastIndex("go gopher", "test")) fmt.Println(strings.LastIndex("go gopher", "go"))　

Output: 0 -1 3

16. func LastIndexAny(s, chars string) int{}

LastIndexAny从s中的字符返回任何Unicode代码点的最后一个实例的索引，如果s中没有来自chars的Unicode代码点，则返回-1。

fmt.Println(strings.LastIndexAny("gogopher", "gp")) fmt.Println(strings.LastIndexAny("gogopher", "jm")) fmt.Println(strings.LastIndexAny("gogopher", "g"))

输出： 4 -1 2

17. func LastIndexByte(s string, c byte) int{}

LastIndexByte返回s中最后一个c实例的索引，如果s中不存在c，则返回-1。 输出： 10 8 -1

18. func LastIndexFunc(s string, f func(rune) bool) int{}

LastIndexFunc将索引返回到满足f（c）的最后一个Unicode代码点的s，如果没有，则返回-1。

fmt.Println(strings.LastIndexFunc("go 123", unicode.IsNumber)) fmt.Println(strings.LastIndexFunc("go 123", unicode.IsLetter)) fmt.Println(strings.LastIndexFunc("123", unicode.IsLetter))

　　

输出： 5 1 -1

19. func Map(mapping func(rune) rune, s string) string{}

Map返回字符串s的副本，其中所有字符都根据映射函数进行了修改。如果映射返回负值，则从字符串中删除该字符而不进行替换。

rot13 := func(r rune) rune { switch { case r >= 'A' && r <= 'Z': return 'A' + (r-'A'+13)%26 case r >= 'a' && r <= 'z': return 'a' + (r-'a'+13)%26 } return r } fmt.Println(strings.Map(rot13, "'Twas brillig and the slithy gopher..."))

　

Output: 'Gjnf oevyyvt naq gur fyvgul tbcure...

20. func Repeat(s string, count int) string{}

Repeat返回一个由字符串s的计数副本组成的新字符串。 如果count为负数或（len（s）* count）的结果溢出，则会发生混乱。

fmt.Println("ba" + strings.Repeat("na", 2))

Output: banana

21. func Replace(s, old, new string, n int) string{}

取代字符串s中的old为new，n为取代的次数

fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2)) fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))

Output: oinky oinky oink moo moo moo

22. func ReplaceAll(s, old, new string) string{}

将就字符串全部体会为新字符串

fmt.Println(strings.ReplaceAll("oink oink oink", "oink", "moo"))

Output: moo moo moo

23. func Split(s, sep string) []string{}

按照sep规则进行切割s字符串，返回值为切片类型

fmt.Printf("%q ", strings.Split("a,b,c", ",")) fmt.Printf("%q ", strings.Split("a man a plan a canal panama", "a ")) fmt.Printf("%q ", strings.Split(" xyz ", "")) fmt.Printf("%q ", strings.Split("", "Bernardo O'Higgins"))

　　

Output:

["a" "b" "c"]

["" "man " "plan " "canal panama"]

[" " "x" "y" "z" " "]

[""]

24. func SplitAfter(s, sep string) []string{}

SplitAfter在每个sep实例之后切入所有子字符串并返回这些子字符串的切片。 如果s不包含sep且sep不为空，则SplitAfter返回长度为1的切片，其唯一元素为s。 如果sep为空，则SplitAfter在每个UTF-8序列之后拆分。如果s和sep都为空，则SplitAfter返回一个空切片。 它相当于SplitAfterN，计数为-1。

fmt.Printf("%q ", strings.SplitAfter("a,b,c", ","))

Output: ["a," "b," "c"]

25. func SplitAfterN(s, sep string, n int) []string{}

SplitAfterN在每个sep实例之后切入子字符串并返回这些子字符串的切片。 计数确定要返回的子字符串数： n> 0：最多n个子串; 最后一个子字符串将是未分割的余数。 n == 0：结果是nil（零子串） n <0：所有子串 s和sep的边缘情况（例如，空字符串）按照SplitAfter文档中的描述进行处理。

fmt.Printf("%q ", strings.SplitAfterN("a,b,c", ",", 2))

Output: ["a," "b,c"]

26. func Title(s string) string{}

Title返回字符串s的副本，其中包含所有Unicode字母，这些字母开始映射到其标题大小写的单词。 BUG（rsc）：标题Title用于单词边界的规则不能正确处理Unicode标点符号。

fmt.Println(strings.Title("her royal highness"))

Output: Her Royal Highness

27. func ToLower(s string) string{}

ToLower返回字符串s的副本，其中所有Unicode字母都映射到它们的小写字母。

fmt.Println(strings.ToLower("Gopher"))　

Output: gopher

29. func ToLowerSpecial(c unicode.SpecialCase, s string) string{}

ToLowerSpecial使用c指定的大小写映射返回字符串s的副本，其中所有Unicode字母都映射到它们的小写字母。

fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "Önnek İş"))

Output: önnek iş

30. func ToUpper(s string) string{}

将s字符串转换为大写

fmt.Println(strings.ToUpper("Gopher"))

Output: GOPHER

31. func ToUpperSpecial(c unicode.SpecialCase, s string) string{}

ToUpperSpecial使用c指定的大小写映射返回字符串s的副本，其中所有Unicode字母都映射到它们的大写字母。

fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "Önnek İş"))

Output: ÖNNEK İŞ

32. func Trim(s string, cutset string) string{}

Trim返回字符串s的一个片段，其中包含cutset中包含的所有前导和尾随Unicode代码点。

fmt.Print(strings.Trim("你好，Gophers !!!", "!"))　

输出：你好，Gophers

33. func TrimFunc(s string, f func(rune) bool) string{}

TrimFunc返回字符串s的一个片段，其中所有前导和尾随的Unicode代码点c都满足f（c）被删除。

fmt.Print(strings.TrimFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool { return !unicode.IsLetter(r) && !unicode.IsNumber(r) }))

Output: Hello, Gophers

34. func TrimLeft(s string, cutset string) string{}

TrimLeft返回字符串s的一个片段，其中包含cutset中包含的所有前导Unicode代码点。 要删除前缀，请改用TrimPrefix。

fmt.Print(strings.TrimLeft("¡¡¡Hello, Gophers!!!", "!¡"))

Output: Hello, Gophers!!!

35. func TrimLeftFunc(s string, f func(rune) bool) string{}

TrimLeftFunc返回字符串s的一个片段，其中所有前导的Unicode代码点c都满足f（c）被删除。

fmt.Print(strings.TrimLeftFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool { return !unicode.IsLetter(r) && !unicode.IsNumber(r) }))　

Output: Hello, Gophers!!!

36. func TrimPrefix(s, prefix string) string{}

TrimPrefix返回s而没有提供的前导前缀字符串。如果s不以prefix开头，则返回s不变。

var s = "¡¡¡Hello, Gophers!!!" s1 := strings.TrimPrefix(s, "¡¡¡Hello, ") fmt.Println(s1) s2 := strings.TrimPrefix(s, "¡¡¡Howdy, ") fmt.Println(s2)

Output:

Gophers!!!

¡¡¡Hello, Gophers!!!

37. func TrimRight(s string, cutset string) string{}

TrimRight返回字符串s的一个片段，删除了cutset中包含的所有尾随Unicode代码点。 要删除后缀，请改用TrimSuffix。

fmt.Print(strings.TrimRight("¡¡¡Hello, Gophers!!!", "!¡"))

Output: ¡¡¡Hello, Gophers

38. func TrimRightFunc(s string, f func(rune) bool) string{}

TrimRightFunc返回字符串s的一个片段，其中所有尾随的Unicode代码点c满足f（c）被删除。

fmt.Print(strings.TrimRightFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool { return !unicode.IsLetter(r) && !unicode.IsNumber(r) }))

　　

Output: ¡¡¡Hello, Gophers

39. func TrimSpace(s string) string{}

TrimSpace返回字符串s的一部分，删除所有前导和尾随空格，如Unicode所定义。

fmt.Println(strings.TrimSpace(" Hello, Gophers "))

Output: Hello, Gophers

40. unc TrimSuffix(s, suffix string) string{}

TrimSuffix返回s而没有提供的尾随后缀字符串。如果s不以后缀结尾，则s保持不变。

var s = "¡¡¡Hello, Gophers!!!" s1 := strings.TrimSuffix(s, ", Gophers!!!") s2 := strings.TrimSuffix(s, ", Marmots!!!") fmt.Println(s1) fmt.Println(s2)

　　

Output:

¡¡¡Hello

¡¡¡Hello, Gophers!!!