go中strings包的完整使用教程

關(guān)于go語言中strings包的完全使用教程

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

比較返回一個(gè)按字典順序比較兩個(gè)字符串的整數(shù)。如果a == b則結(jié)果為0，如果a <b則結(jié)果為-1，如果a> b則結(jié)果為+1。
此外：僅包含與包字節(jié)對稱的比較。使用內(nèi)置字符串比較運(yùn)算符==，<，>等通常更清晰，速度更快。
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轉(zhuǎn)化為unicode編碼，然后判斷r是否在其中，返回值類型為bool值
//查找字符串是否包含特定的Unicode代碼點(diǎn)。
//例如，小寫字母“a”的代碼點(diǎn)是97. 
fmt.Println（strings.ContainsRune（“aardvark”，97））
fmt.Println（strings.ContainsRune（“timeout”，97））
輸出：

真
假

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

統(tǒng)計(jì)字符串s中substr字符串的個(gè)數(shù)，返回值類型為×××。
如果substr是空字符串，則Count返回1 + s包含的個(gè)數(shù)
fmt.Println（strings.Count（“cheese”，“e”））
fmt.Println（strings.Count（“five”，“”））//在每個(gè)符文之前和之后
輸出：

3 
5

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

不考慮大小寫，判斷字符串s、t是否相同，返回值類型為布爾值
fmt.Println（strings.EqualFold（“Go”，“go”））
輸出：

true

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

按照空格進(jìn)行切分，將字符串s切割成一個(gè)切片。返回值類型為切片類型
fmt.Printf（“Fields are：％q”，strings.Fields（“foo bar baz”））
輸出：

字段是：[“foo”“bar”“baz”]

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

FieldsFunc在每次運(yùn)行滿足f（c）的Unicode代碼點(diǎn)c時(shí)拆分字符串s，并返回s的切片數(shù)組。如果s中的所有代碼點(diǎn)滿足f（c）或字符串為空，則返回空切片。FieldsFunc不保證它調(diào)用f（c）的順序。如果f沒有返回給定c的一致結(jié)果，則FieldsFunc可能會(huì)崩潰。
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字符串結(jié)束的，返回值類型為布爾值
注意：若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{}

返回第一個(gè)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中的第一個(gè)索引，若無，則返回-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中第一個(gè)c實(shí)例的索引，如果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）的第一個(gè)Unicode代碼點(diǎn)的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代碼點(diǎn)r的第一個(gè)實(shí)例的索引，如果s中不存在符文，則返回-1。如果r是utf8.RuneError，則返回任何無效的UTF-8字節(jié)序列的第一個(gè)實(shí)例。

fmt.Println（strings.IndexRune（“chicken”，“k”））
fmt.Println（strings.IndexRune（“chicken”，“d”））
輸出：

4 
-1

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

將切片按照sep進(jìn)行連接，形成一個(gè)字符串
s := []string{"foo", "bar", "baz"}
fmt.Println(strings.Join(s, ", "))
Output:

foo, bar, baz

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

返回字符串s包含substr最后的一個(gè)索引值，沒有找到就返回-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代碼點(diǎn)的最后一個(gè)實(shí)例的索引，如果s中沒有來自chars的Unicode代碼點(diǎn)，則返回-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中最后一個(gè)c實(shí)例的索引，如果s中不存在c，則返回-1。
fmt.Println（strings.LastIndexByte（“Hello，world”，“l(fā)”））
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）的最后一個(gè)Unicode代碼點(diǎn)的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的副本，其中所有字符都根據(jù)映射函數(shù)進(jìn)行了修改。如果映射返回負(fù)值，則從字符串中刪除該字符而不進(jìn)行替換。
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返回一個(gè)由字符串s的計(jì)數(shù)副本組成的新字符串。

如果count為負(fù)數(shù)或（len（s）* count）的結(jié)果溢出，則會(huì)發(fā)生混亂。
fmt.Println("ba" + strings.Repeat("na", 2))
Output:

banana

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

取代字符串s中的old為new，n為取代的次數(shù)
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{}

將就字符串全部體會(huì)為新字符串
fmt.Println(strings.ReplaceAll("oink oink oink", "oink", "moo"))
Output:

moo moo moo

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

按照sep規(guī)則進(jìn)行切割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在每個(gè)sep實(shí)例之后切入所有子字符串并返回這些子字符串的切片。

如果s不包含sep且sep不為空，則SplitAfter返回長度為1的切片，其唯一元素為s。

如果sep為空，則SplitAfter在每個(gè)UTF-8序列之后拆分。如果s和sep都為空，則SplitAfter返回一個(gè)空切片。

它相當(dāng)于SplitAfterN，計(jì)數(shù)為-1。
fmt.Printf("%q\n", strings.SplitAfter("a,b,c", ","))
Output:

["a," "b," "c"]

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

SplitAfterN在每個(gè)sep實(shí)例之后切入子字符串并返回這些子字符串的切片。

計(jì)數(shù)確定要返回的子字符串?dāng)?shù)：

n> 0：最多n個(gè)子串; 最后一個(gè)子字符串將是未分割的余數(shù)。
n == 0：結(jié)果是nil（零子串）
n <0：所有子串
s和sep的邊緣情況（例如，空字符串）按照SplitAfter文檔中的描述進(jìn)行處理。
fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 2))
Output:

["a," "b,c"]

26. func Title(s string) string{}

Title返回字符串s的副本，其中包含所有Unicode字母，這些字母開始映射到其標(biāo)題大小寫的單詞。

BUG（rsc）：標(biāo)題Title用于單詞邊界的規(guī)則不能正確處理Unicode標(biāo)點(diǎn)符號(hào)。
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字符串轉(zhuǎn)換為小寫
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字符串轉(zhuǎn)換為大寫
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的一個(gè)片段，其中包含cutset中包含的所有前導(dǎo)和尾隨Unicode代碼點(diǎn)。
fmt.Print（strings.Trim（“你好，Gophers !!!”，“！?”））
輸出：

你好，Gophers

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

TrimFunc返回字符串s的一個(gè)片段，其中所有前導(dǎo)和尾隨的Unicode代碼點(diǎn)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的一個(gè)片段，其中包含cutset中包含的所有前導(dǎo)Unicode代碼點(diǎn)。

要?jiǎng)h除前綴，請改用TrimPrefix。
fmt.Print(strings.TrimLeft("???Hello, Gophers!!!", "!?"))
Output:

Hello, Gophers!!!

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

TrimLeftFunc返回字符串s的一個(gè)片段，其中所有前導(dǎo)的Unicode代碼點(diǎn)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而沒有提供的前導(dǎo)前綴字符串。如果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的一個(gè)片段，刪除了cutset中包含的所有尾隨Unicode代碼點(diǎn)。

要?jiǎng)h除后綴，請改用TrimSuffix。
fmt.Print(strings.TrimRight("???Hello, Gophers!!!", "!?"))
Output:

???Hello, Gophers

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

TrimRightFunc返回字符串s的一個(gè)片段，其中所有尾隨的Unicode代碼點(diǎn)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的一部分，刪除所有前導(dǎo)和尾隨空格，如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不以后綴結(jié)尾，則s保持不變。
var s = "???Hello, Gophers!!!"
s = strings.TrimSuffix(s, ", Gophers!!!")
s = strings.TrimSuffix(s, ", Marmots!!!")
fmt.Print(s)
Output:

???Hello