[Go语言tips06]浅谈strings包

0.引言

标准库的strings包是在对字符串操作中很常用的一个内容，基本上包含了go语言对string字符串类型的所有基本操作：
查找、替换、拼接、分割、删除、转换。

下面就依次对常用的方法进行说明以及演示，之后遇到各种对字符串操作的问题也可以快速的找到合适的方法来进行应对。

1.字符串查找

所谓字符串查找就是在一个字符串内找到另一个字符串或者某一个字符串中的任意一个字符，方式有很多，只对其中比较实用的进行介绍。
以下内容中，substr的意思是连续且完整的字符串，chars的意思是其中任意一个字符；对于返回位置的方法，如果没有找到则返回-1。

方法名	说明
Count(s, substr string)int	返回字符串s中包含字符串substr的个数
Contains(s, substr string)bool	判断字符串s中是否包含字符串substr
ContainsAny(s, chars string)bool	判断字符串s中是否包含字符串chars中任意一个字符
Index(s, substr string)int	返回字符串s中字符串substr首次出现的位置
LastIndex(s, substr string)int	返回字符串s中字符串substr最后一次出现的位置
IndexAny(s, chars string)int	返回字符串s中字符串chars中任意一个字符的首次出现的位置
LastIndexAny(s, chars string)int	返回字符串s中字符串chars中任意一个字符的最后一次出现的位置
HasPrefix(s, prefix string)bool	判断字符串s是否含有前缀prefix
HasSuffix(s, suffix string)bool	判断字符串s是否含有后缀suffix

package main
import (
	"fmt"
	"strings"
)
func main() {
	s := "golang go std strings"
	// 返回s中包含substr的个数(连续且完整)
	fmt.Println(strings.Count(s, "go")) // 2
	// 判断s中是否包含substr(连续且完整)
	fmt.Println(strings.Contains(s, "go"))    // true
	fmt.Println(strings.Contains(s, "hello")) // false
	// 判断s中是否包含chars中任意一个字符
	fmt.Println(strings.ContainsAny(s, "hello")) // true
	fmt.Println(strings.ContainsAny(s, "jz"))    // false
	// 返回s中substr首次出现的位置(起始位置，没有返回-1)
	fmt.Println(strings.Index(s, "go")) // 0
	fmt.Println(strings.Index(s, "jz")) // -1
	// 返回s中substr最后一次出现的位置(起始位置，没有返回-1)
	fmt.Println(strings.LastIndex(s, "go")) // 7
	// 返回s中首次出现的chars中任意一个字符的位置
	fmt.Println(strings.IndexAny(s, "s")) // 10
	// 返回s中最后一次出现的chars中任意一个字符的位置
	fmt.Println(strings.LastIndexAny(s, "s")) // 20
	// 判断s是否有前缀prefix
	fmt.Println(strings.HasPrefix(s, "golan")) // true
	fmt.Println(strings.HasPrefix(s, "rings")) // false
	// 判断s是否有后缀suffix
	fmt.Println(strings.HasSuffix(s, "rings")) // true
	fmt.Println(strings.HasSuffix(s, "golan")) // false
}

2.字符串替换

字符串替换就是把字符串s中的a子串替换成b子串，这一操作只有两个方法：

方法名	说明
Replace(s, old, new string, n int)string	将字符串s中前n个old子串替换为new子串(n<0会替换全部)
ReplaceAll(s, old, new string) string	将字符串s中全部的old子串替换为new子串

package main
import (
	"fmt"
	"strings"
)
func main() {
	s := "1 2 3 4 5"
	oldStr := " "
	newStr := ","
	// 将字符串s中前n个old子串替换为new子串(n<0会替换全部)
	fmt.Println(strings.Replace(s, oldStr, newStr, 2))  // 1,2,3 4 5
	fmt.Println(strings.Replace(s, oldStr, newStr, -1)) // 1,2,3,4,5
	// 将字符串s中全部的old子串替换为new子串
	fmt.Println(strings.ReplaceAll(s, oldStr, newStr)) // 1,2,3,4,5
}

3.字符串拼接

字符串拼接就是把一个字符串的切片按照规则合并成一个字符串。

方法名	说明
Join(elems []string, sep string) string	将字符串切片elems使用sep作为分割符拼接成一个字符串
Repeat(s string, count int) string	将字符串s重复count遍拼接成一个字符串

package main
import (
	"fmt"
	"strings"
)
func main() {
	s := "golang"
	elems := []string{"1", "2", "3", "4"}
	// 将字符串切片elems使用sep作为分割符拼接成一个字符串
	fmt.Println(strings.Join(elems, ""))  // 1234
	fmt.Println(strings.Join(elems, ",")) // 1,2,3,4
	// 将字符串s重复count遍拼接成一个字符串
	fmt.Println(strings.Repeat(s, 5)) // golanggolanggolanggolanggolang
}

4.字符串分割

字符串分割是把一个字符串按照规则分割成一个字符串切片，是拼接的逆过程。

方法名	说明
Fields(s string)[]string	返回将字符串s以空格分割后的切片(无视一切空格)
Split(s,sep string)[]string	返回将字符串s以sep分割后的切片(不能无视空格)
SplitN(s,sep string, n int)[]string	返回将字符串s以sep分割后的切片(不能无视空格),只切前n个
SplitAfter(s,sep string)[]string	返回将字符串s以sep分割后的切片,并且除了最后一个元素外其余后面都带着sep(不能无视空格)
SplitAfterN(s,sep string, n int)[]string	返回将字符串s以sep分割后的切片,并且除了最后一个元素外其余后面都带着sep(不能无视空格),只切前n个

非常要注意的一个问题就是，Split的切割是两个sep(或是sep到结束)之间的所有内容，不能忽略掉空格，比如下面的t4中切片的内容是："1", "2", " 3", "4 ", "5", " ", " 6"。

package main
import (
	"fmt"
	"strings"
)
func main() {
	s1 := "1 2 3 4 , 5     !6  "
	s2 := "1,2, 3,4,5, "
	s3 := "1,2, 3,4 ,5, , 6"
	// 返回将字符串s以空格分割后的切片(无视一切空格)
	t1 := strings.Fields(s1)
	fmt.Println(t1, len(t1)) // [1 2 3 4 , 5 !6] 7
	// 返回将字符串s以sep分割后的切片(不能无视空格)
	t2 := strings.Split(s2, ",")
	fmt.Println(t2, len(t2)) // [1 2  3 4 5  ] 6  其中" 3"和" "都是被切割出来的字符串
	// 返回将字符串s以sep分割后的切片(不能无视空格),只切前n个
	t3 := strings.SplitN(s2, ",", 3)
	fmt.Println(t3, len(t3)) // [1 2  3,4,5, ] 3
	// 返回将字符串s以sep分割后的切片,并且除了最后一个元素外其余后面都带着sep(不能无视空格)
	t4 := strings.SplitAfter(s3, ",")
	fmt.Println(t4, len(t4)) // [1, 2,  3, 4 , 5,  ,  6] 7
	// 返回将字符串s以sep分割后的切片,并且除了最后一个元素外其余后面都带着sep(不能无视空格),只切前n个
	t5 := strings.SplitAfterN(s3, ",", 3)
	fmt.Println(t5, len(t5)) // [1, 2,  3,4 ,5, , 6] 3
}

5.字符串删除

字符串删除的方法都是对字符串首尾进行操作的，至于中间的删除完全可以通过Replace替换为空。

方法名	说明
Trim(s,cutset string)string	将字符串s首尾所有在cutset中出现过的字符删除
TrimLeft(s,cutset string)string	将字符串s左侧所有在cutset中出现过的字符删除
TrimRight(s,cutset string) string	将字符串s右侧所有在cutset中出现过的字符删除
TrimPrefix(s,prefix string)string	将字符串s前缀字符串prefix删除
TrimSuffix(s, suffix string) string	将字符串s后缀字符串suffix删除
TrimSpace(s string) string	将字符串s首尾空格删除

package main
import (
	"fmt"
	"strings"
)
func main() {
	s1 := "%!@#hello!()g0lang*!&^"
	s2 := " x %!@#hello!()g0lang*!&^     "
	cutset := "!@#$%^&*()"
	// 	将字符串s首尾所有在cutset中出现过的字符删除
	fmt.Println(strings.Trim(s1, cutset)) // "hello!()g0lang"
	//	将字符串s左侧所有在cutset中出现过的字符删除
	fmt.Println(strings.TrimLeft(s1, cutset)) // "hello!()g0lang*!&^"
	//	将字符串s右侧所有在cutset中出现过的字符删除
	fmt.Println(strings.TrimRight(s1, cutset)) // "%!@#hello!()g0lang"
	//	将字符串s前缀字符串prefix删除
	fmt.Println(strings.TrimPrefix(s1, "%!@")) // "#hello!()g0lang*!&^"
	//	将字符串s后缀字符串suffix删除
	fmt.Println(strings.TrimSuffix(s1, "&^")) // "%!@#hello!()g0lang*!"
	//	将字符串s首尾空格删除
	fmt.Println(strings.TrimSpace(s2)) // "x %!@#hello!()g0lang*!&^"
}

6.字符串转换

字符串转换一般就是指大小写之间的转换

方法名	说明
Title(s string)string	将字符串s每个单词首字母大写
ToLower(s string)string	将字符串s转换成小写返回
ToUpper(s string)string	将字符串s转换成大写返回

package main
import (
	"fmt"
	"strings"
)
func main() {
	s := "Hello worlD!"
	// 	将字符串s每个单词首字母大写
	fmt.Println(strings.Title(s)) // Hello WorlD!
	//	将字符串s转换成小写返回
	fmt.Println(strings.ToLower(s)) // hello world!
	// 	将字符串s转换成大写返回
	fmt.Println(strings.ToUpper(s)) // HELLO WORLD!
}