go中strings包的完整使用教程


关于go语言中strings包的完全使用教程

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”,“u&i”))
fmt.Println(strings.ContainsAny(“foo”,“” ))
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))
输出:

真
假

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”))
输出:

字段是:[“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(“foo1; bar2,baz3。 ..“, F))
输出:

字段是:[“foo1”“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
false
false
true

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

返回第一个s中包含substr 的字符的索引,若无则返回-1
fmt.Println(strings.Index("chicken", "ken"))
fmt.Println(strings.Index("chicken", "dmr"))
Output:

4
-1

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

先判断s与chars中是否有相同的元素,若有则返回相同元素在s中的第一个索引,若无,则返回-1
mt.Println(strings.IndexAny(“chicken”,“aeiouy”))
fmt.Println(strings.IndexAny(“crwth”,“aeiouy”))
输出:

2 
-1

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

IndexByte返回s中第一个c实例的索引,如果s中不存在c,则返回-1。
fmt.Println(strings.IndexByte(“golang”,“g”))
fmt.Println(strings.IndexByte(“gophers”,“h”))
fmt.Println(strings.IndexByte(“golang”,“x”) )
输出:

0 
3 
-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,世界”,f))
fmt.Println(strings.IndexFunc(“你好,世界“,f))
输出:

7 
-1

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

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

fmt.Println(strings.IndexRune(“chicken”,“k”))
fmt.Println(strings.IndexRune(“chicken”,“d”))
输出:

4 
-1

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", "go"))
fmt.Println(strings.LastIndex("go gopher", "rodent"))
Output:

0
3
-1

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

LastIndexAny从s中的字符返回任何Unicode代码点的最后一个实例的索引,如果s中没有来自chars的Unicode代码点,则返回-1。
fmt.Println(strings.LastIndexAny(“go gopher”,“go”))
fmt.Println(strings.LastIndexAny(“go gopher”,“rodent”))
fmt.Println(strings.LastIndexAny(“go gopher”,“失败”))
输出:

4 
8 
-1

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

LastIndexByte返回s中最后一个c实例的索引,如果s中不存在c,则返回-1。
fmt.Println(strings.LastIndexByte(“Hello,world”,“l”))
fmt.Println(strings.LastIndexByte(“Hello,world”,“o”))
fmt.Println(strings.LastIndexByte(“Hello,world,world “, 'X'))
输出:

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(“123 go”,unicode.IsNumber))
fmt.Println(strings.LastIndexFunc(“go”,unicode。 ISNUMBER))
输出:

5 
2 
-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/n", strings.Split("a,b,c", ","))
fmt.Printf("%q/n", strings.Split("a man a plan a canal panama", "a "))
fmt.Printf("%q/n", strings.Split(" xyz ", ""))
fmt.Printf("%q/n", 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/n", 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/n", 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

28. func ToLower(s string) string{}

将s字符串转换为小写
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 ToLowerSpecial(c unicode.SpecialCase, s string) string{}

ToUpperSpecial使用c指定的大小写映射返回字符串s的副本,其中所有Unicode字母都映射到它们的大写字母。
fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "Önnek İş"))
Output:

önnek iş

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!!!"
s = strings.TrimPrefix(s, "¡¡¡Hello, ")
s = strings.TrimPrefix(s, "¡¡¡Howdy, ")
fmt.Print(s)
Output:

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(" /t/n Hello, Gophers /n/t/r/n"))
Output:

Hello, Gophers

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

TrimSuffix返回s而没有提供的尾随后缀字符串。如果s不以后缀结尾,则s保持不变。
var s = "¡¡¡Hello, Gophers!!!"
s = strings.TrimSuffix(s, ", Gophers!!!")
s = strings.TrimSuffix(s, ", Marmots!!!")
fmt.Print(s)
Output:

¡¡¡Hello