1. Count 计算字符串 sep 在 s 中的非重叠个数
如果 sep 为空字符串，则返回 s 中的字符(非字节)个数 + 1
func Count(s, chars string) int
func main() {
a := "你好呀 Golang !!!!"
n := strings.Count(a, "!!")
n2 := strings.Count(a, "")
fmt.Println(n, n2, len(a), utf8.RuneCountInString(a), len([]rune(a))) // 2 16 21 15 15
}
2. Contains 判断字符串 s 中是否包含子串 substr
如果 substr 为空，则返回 true
func Contains(s, substr string) bool
func main() {
a := "你好呀 Golang !!!!"
fmt.Println(strings.Contains(a, "你好")) // true
fmt.Println(strings.Contains(a, "!!")) // true
fmt.Println(strings.Contains(a, "")) // true
fmt.Println(strings.Contains(a, "ac")) // false
}
3. ContainsAny 判断字符串 s 中是否包含 chars 中的任何一个字符
如果 substr 为空，则返回 false
func ContainsAny(s, chars string) bool
func main() {
a := "你好呀 Golang !!!!"
fmt.Println(strings.ContainsAny(a, "你好")) // true
fmt.Println(strings.ContainsAny(a, "你坏")) // true
fmt.Println(strings.ContainsAny(a, "我坏")) // false
fmt.Println(strings.ContainsAny(a, "")) // false
}
4. ContainsRune 判断字符串 s 中是否包含字符 r
func ContainsRune(s string, r rune) bool
rune 不允许为空
func main() {
// rune = int32 byte = uint8
a := "你好呀 Golang !!!!"
b := strings.ContainsRune(a, '!') // true
c := strings.ContainsRune(a, '呀') // true
d := strings.ContainsRune(a, 0) // false
e := strings.ContainsRune(a, 97) // true
fmt.Println(b, c, d, e)
}
5. Index 返回子串 sep 在字符串 s 中第一次出现的位置
func Index(s, sep string) int
如果找不到，则返回 -1，如果 sep 为空，则返回 0。
func main() {
// 中文占3个长度,英文及符号占1个长度
a := "你好呀 Golang !!!!"
b := strings.Index(a, " ") //9
c := strings.Index(a, "好") //3
d := strings.Index(a, "") //0
fmt.Println(b, c, d)
}
6. LastIndex 返回子串 sep 在字符串 s 中最后一次出现的位置
func LastIndex(s, sep string) int
如果找不到，则返回 -1，如果 sep 为空，则返回 0。
func main() {
// 中文占3个长度,英文及符号占1个长度
a := "你好呀 Golang !!!!"
b := strings.LastIndex(a, " ") // 16
c := strings.LastIndex(a, "好") //3
d := strings.LastIndex(a, "") //0
fmt.Println(b, c, d)
}
7. IndexRune 返回字符 r 在字符串 s 中第一次出现的位置
func IndexRune(s string, r rune) int
如果找不到，则返回 -1
func main() {
// 中文占3个长度,英文及符号占1个长度
a := "你好呀 Golang !!!!"
b := strings.IndexRune(a, 97) // 13
c := strings.IndexRune(a, 0) // -1
d := strings.IndexRune(a, 'o') // 11
fmt.Println(b, c, d)
}
8. IndexAny 返回字符串 chars 中的任何一个字符在字符串 s 中第一次出现的位置
func IndexAny(s, chars string) int
如果找不到，则返回 -1，如果 chars 为空，则返回 -1
LastIndexAny 同理
func main() {
// 中文占3个长度,英文及符号占1个长度
a := "你好呀 Golang !!!!"
b := strings.IndexAny(a, "pyth") // 13
c := strings.IndexAny(a, "我不好") // -1
d := strings.IndexAny(a, "嗯呐") // 11
fmt.Println(b, c, d)
}
9. SplitN 以 sep 为分隔符，将 s 切分成多个子串，结果中不包含 sep 本身
如果 sep 为空，则将 s 切分成 Unicode 字符列表。
如果 s 中没有 sep 子串，则将整个 s 作为 []string 的第一个元素返回
参数 n 表示最多切分出几个子串，超出的部分将不再切分。
如果 n 为 0，则返回 nil，如果 n 小于 0，则不限制切分个数，全部切分func SplitN(s, sep string, n int) []string
func main() {
s := "Hello, 世界! Hello!"
ss := strings.SplitN(s, " ", 2)
fmt.Printf("%q\n", ss) // ["Hello," "世界! Hello!"]
ss = strings.SplitN(s, " ", -1)
fmt.Printf("%q\n", ss) // ["Hello," "世界!" "Hello!"]
ss = strings.SplitN(s, "", 3)
fmt.Printf("%q\n", ss) // ["H" "e" "llo, 世界! Hello!"]
}
10. SplitAfterN 以 sep 为分隔符，将 s 切分成多个子串，结果中包含 sep 本身
如果 sep 为空，则将 s 切分成 Unicode 字符列表。
如果 s 中没有 sep 子串，则将整个 s 作为 []string 的第一个元素返回
参数 n 表示最多切分出几个子串，超出的部分将不再切分。
如果 n 为 0，则返回 nil，如果 n 小于 0，则不限制切分个数，全部切分func SplitAfterN(s, sep string, n int) []string
func main() {
s := "Hello, 世界! Hello!"
ss := strings.SplitAfterN(s, " ", 2)
fmt.Printf("%q\n", ss) // ["Hello, " "世界! Hello!"]
ss = strings.SplitAfterN(s, " ", -1)
fmt.Printf("%q\n", ss) // ["Hello, " "世界! " "Hello!"]
ss = strings.SplitAfterN(s, "", 3)
fmt.Printf("%q\n", ss) // ["H" "e" "llo, 世界! Hello!"]
}
11. Split 以 sep 为分隔符，将 s 切分成多个子切片，结果中不包含 sep 本身
如果 sep 为空，则将 s 切分成 Unicode 字符列表。
如果 s 中没有 sep 子串，则将整个 s 作为 []string 的第一个元素返回func Split(s, sep string) []string
func main() {
s := "Hello, 世界! Hello!"
ss := strings.Split(s, " ")
fmt.Printf("%q\n", ss) // ["Hello," "世界!" "Hello!"]
ss = strings.Split(s, ", ")
fmt.Printf("%q\n", ss) // ["Hello" "世界! Hello!"]
ss = strings.Split(s, "")
fmt.Printf("%q\n", ss) // ["H" "e" "l" "l" "o" "," " " "世" "界" "!" " " "H" "e" "l" "l" "o" "!"]
}
12. SplitAfter 以 sep 为分隔符，将 s 切分成多个子切片，结果中包含 sep 本身
如果 sep 为空，则将 s 切分成 Unicode 字符列表。
如果 s 中没有 sep 子串，则将整个 s 作为 []string 的第一个元素返回func SplitAfter(s, sep string) []string
func main() {
s := "Hello, 世界! Hello!"
ss := strings.SplitAfter(s, " ")
fmt.Printf("%q\n", ss) // ["Hello, " "世界! " "Hello!"]
ss = strings.SplitAfter(s, ", ")
fmt.Printf("%q\n", ss) // ["Hello, " "世界! Hello!"]
ss = strings.SplitAfter(s, "")
fmt.Printf("%q\n", ss) // 单个字符列表
}
13. Fields 以连续的空白字符为分隔符，将 s 切分成多个子串，结果中不包含空白字符本身
空白字符有：\t, \n, \v, \f, \r, ' ', U+0085 (NEL), U+00A0 (NBSP)
如果 s 中只包含空白字符，则返回一个空列表
func Fields(s string) []string
func main() {
s := "Hello, 世界! Hello!"
ss := strings.Fields(s)
fmt.Printf("%q\n", ss) // ["Hello," "世界!" "Hello!"]
}
14. FieldsFunc 以一个或多个满足 f(rune) 的字符为分隔符
将 s 切分成多个子串，结果中不包含分隔符本身。
如果 s 中没有满足 f(rune) 的字符，则返回一个空列表。
#####func FieldsFunc(s string, f func(rune) bool) []string
func isSlash(r rune) bool {
return r == '\' || r == '/'
}
func main() {
s := "C:\Windows\System32\FileName"
ss := strings.FieldsFunc(s, isSlash)
fmt.Printf("%q\n", ss) // ["C:" "Windows" "System32" "FileName"]
}
15. Join 将 a 中的子串连接成一个单独的字符串，子串之间用 sep 分隔
func Join(a []string, sep string) string
func main() {
var lis []string
lis = []string{"name", "age", "sex"}
ret := strings.Join(lis, "|")
fmt.Println(ret)
}
// name|age|sex
16. HasPrefix 判断字符串 s 是否以 prefix 开头
func HasPrefix(s, prefix string) bool
func main() {
s := "Golang世界真美妙"
b := strings.HasPrefix(s, "Golang") // true
c := strings.HasPrefix(s, "lang") // false
fmt.Println(b, c)
}
17. HasSuffix 判断字符串 s 是否以 suffix 结尾
func HasSuffix(s, suffix string) bool
func main() {
s := "Golang世界真美妙"
b := strings.HasSuffix(s, "美妙") // true
c := strings.HasSuffix(s, "Golang") // false
fmt.Println(b, c)
}
18. Map 将 s 中满足 mapping(rune) 的字符替换为 mapping(rune) 的返回值
如果 mapping(rune) 返回负数，则相应的字符将被删除。
func Map(mapping func(rune) rune, s string) string
场景: 用于字符的批量替换
func f(r rune) rune {
if r == 'o' {
// 如果次数返回负数 就代表满足条件的字符就会在字符串中删除掉
return -1
}
return r
}
func main() {
s := "Golang世界真美妙"
ms := strings.Map(f, s)
fmt.Println(ms)
}
19. Repeat 将 count 个字符串 s 连接成一个新的字符串
func Repeat(s string, count int) string
func main() {
s := "Hello!"
rs := strings.Repeat(s, 3)
fmt.Printf("%q\n", rs) // "Hello!Hello!Hello!"
}
