1. 判断字串函数

1）EqualFold() 判断字串相等

语法

func EqualFold(s string, t string) bool
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "诸葛亮"
	dstString := "孔明"
	if strings.EqualFold(srcString,dstString){
		fmt.Printf("【%s】和【%s】是一个人。\n",srcString,dstString)
	}else {
		fmt.Printf("【%s】和【%s】不是一个人。\n",srcString,dstString)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出

【诸葛亮】和【孔明】不是一个人。
1

示例（不区分大小写）

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "liuBei"
	dstString := "LiuBei"
	if strings.EqualFold(srcString,dstString){
		fmt.Printf("【%s】和【%s】是一个人。\n",srcString,dstString)
	}else {
		fmt.Printf("【%s】和【%s】不是一个人。\n",srcString,dstString)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出

【liuBei】和【LiuBei】是一个人。
1

2）HasPrefix() 判断前缀

语法

func HasPrefix(s string, prefix string) bool
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德"
	preString := "刘"
	if strings.HasPrefix(srcString,preString){
		fmt.Println("Yes")
  }else{
	  fmt.Println("No")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出

Yes
1

3）HasSuffix() 判断后缀

语法

func HasSuffix(s, suffix string) bool
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德"
	preString := "玄德"
	if strings.HasSuffix(srcString,preString){
		fmt.Println("Yes")
  }else{
	  fmt.Println("No")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 输出

Yes
1

4）Contains() 判断是否包含子字串

语法

func Contains(s, substr string) bool
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "《咏怀古迹·诸葛大名垂宇宙》"
	subString := "诸葛"
	if strings.Contains(srcString,subString){
		fmt.Println("Yes")
	}else {
		fmt.Println("No")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 输出

Yes
1

5）ContainsRune() 判断是否包含r值

语法

func ContainsRune(s string, r rune) bool
1

判断字符串s是否包含utf-8码值r

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "liuBei"
	subRune := 'B'
	if strings.ContainsRune(srcString,subRune){
		fmt.Println("Yes")
	}else {
		fmt.Println("No")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 输出

Yes
1

6）ContainsAny() 判断包含字串中任一字符

语法

func ContainsAny(s, chars string) bool
1

判断字符串s是否包含字符串chars中的任一字符。

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德"
	charString := "刘关张"
	if strings.ContainsAny(srcString,charString){
		fmt.Println("Yes")
	}else {
		fmt.Println("No")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 输出

Yes
1

2. 统计函数

1） Count() 统计出现次数

语法

func Count(s, sep string) int
1

返回字符串s中有几个不重复的sep子串。

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德"
	sepString := "刘"

	num := strings.Count(srcString,sepString)
	fmt.Println(num)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出

2
1

2）Index() 判断首次匹配到位置

语法

子串sep在字符串s中第一次出现的位置，不存在则返回-1。

func Index(s, sep string) int
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德"
	sepString := "备"

	num := strings.Index(srcString,sepString)
	fmt.Println(num)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出

3
1

说明：编号从0开始，汉字占三个字符。即 刘占 0、1、2 三个字符， 因此备从3开始。

3）IndexByte() 查byte在string中的位置

语法

func IndexByte(s string, c byte) int
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	srcString := "liuBei"
	myByte := byte('e')
	site := strings.IndexByte(srcString,myByte)
	fmt.Println(site)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出

4
1

4）IndexRune() 查找r值在string中的位置

语法

func IndexRune(s string, r rune) int
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	srcString := "liuBei"
	site := strings.IndexRune(srcString,'B')
	fmt.Println(site)
}
1
2
3
4
5
6
7
8
9
10
11
12

• 结果输出

3
1

5）IndexAny() 查找子字串任意字符的位置

语法

func IndexAny(s, chars string) int
1

查找s从左匹配到chars中任一字符的位置

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	srcString := "功盖三分国，名成八阵图"
	charsString := "二五八"
	site := strings.IndexAny(srcString,charsString)
	fmt.Println(site)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 结果

24
1

说明：汉字和汉语标点每个3字符，从0算起，成 占 21、22、23，八从24开始，因此结果是24

如果改成：charsString := "三五八" 则只能匹配到srcString中的三，结果为6

6）LastIndex() 从右端起首次匹配位置

语法

func LastIndex(s, sep string) int
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	srcString := "刘备刘玄德"
	sepString := "刘"
	site := strings.LastIndex(srcString, sepString)
	fmt.Println(site)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

结果

6
1

7）LastIndexAny() 从右起查找子字串任意字符的位置

语法

func LastIndexAny(s, chars string) int
1

字符chars中的任一utf-8码值在s中最后一次出现的位置，如不存在或者chars为空字符串则返回-1。

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德"
	charsString := "刘关张"
	site := strings.LastIndexAny(srcString,charsString)
	fmt.Println(site)
}
1
2
3
4
5
6
7
8
9
10
11
12

结果

6
1

从0 起，一个汉字三个字符，第二个刘的位置从6开始。

3. 大小写转换函数

1）Title( ) 转换为标题

以词首字母大写，其他大小写不变

语法

func Title(s string) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "hello worlD"
	titleString := strings.Title(srcString)
	fmt.Println(titleString)
}
1
2
3
4
5
6
7
8
9
10
11

-输出

Hello WorlD
1

• 词首变成大写
• 后边的大写不会变成小写

2）ToTitle() 全文转标题

语法

func ToTitle(s string) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "liuBei xuanDE"
	titleString := strings.ToTitle(srcString)
	fmt.Println(titleString)
}
1
2
3
4
5
6
7
8
9
10
11

• 显示

LIUBEI XUANDE
1

3）ToLower() 大写转小写

语法

func ToLower(s string) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "HELLO world"
	lowerString := strings.ToLower(srcString)
	fmt.Println(lowerString)
}
1
2
3
4
5
6
7
8
9
10
11

• 结果

hello world
1

4）ToUpper() 小写转大写

语法

func ToUpper(s string) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "HELLO world"
	upperString := strings.ToUpper(srcString)
	fmt.Println(upperString)
}
1
2
3
4
5
6
7
8
9
10
11

输出

hello world
1

4. 裁切函数

1）Trim() 首尾裁切字串

语法

裁切掉s头尾的cutset字串

func Trim(s string, cutset string) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德刘"
	cutString := "刘"
	resultString := strings.Trim(srcString,cutString)
	fmt.Println(resultString)
}
1
2
3
4
5
6
7
8
9
10
11
12

• 结果

备刘玄德
1

头尾的刘字同时被剪切

2）TrimSpace() 首尾裁切空白

语法

func TrimSpace(s string) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "   关羽关云长"
	resultString := strings.TrimSpace(srcString)
	fmt.Printf("源字串： %q\n裁切后： %q\n", srcString,resultString)
}
1
2
3
4
5
6
7
8
9
10
11

• 结果

源字串： "   关羽关云长"
裁切后： "关羽关云长"
1
2

3）TrimLeft() 只裁左侧

语法

func TrimLeft(s string, cutset string) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德刘"
	cutString := "刘"
	resultString := strings.TrimLeft(srcString,cutString)
	fmt.Println(resultString)
}
1
2
3
4
5
6
7
8
9
10
11
12

结果

备刘玄德刘
1

4）TrimPrefix() 裁切头部

语法

func TrimPrefix(s, prefix string) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德"
	cutString := "刘备"
	resultString := strings.TrimPrefix(srcString,cutString)
	fmt.Println(resultString)
}
1
2
3
4
5
6
7
8
9
10
11
12

• 结果

刘玄德
1

5）TrimRight() 右侧裁切

语法

func TrimRight(s string, cutset string) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "刘备刘玄德"
	cutString := "玄德"
	resultString := strings.TrimRight(srcString,cutString)
	fmt.Println(resultString)
}
1
2
3
4
5
6
7
8
9
10
11
12

• 结果

刘备刘
1

6）TrimSuffix() 尾部裁切

语法

func TrimSuffix(s, suffix string) string
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	srcString := "刘备刘玄德"
	cutString := "玄德"
	resultString := strings.TrimSuffix(srcString,cutString)
	fmt.Println(resultString)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出

刘备刘
1

5. 切割函数

1）Split() 切割字串（不含分隔符）

语法

func Split(s, sep string) []string
1

用sep切割字串s，结果不含分隔符sep。

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	srcString := "10.10.239.58"
	sepString := "."
	resultString := strings.Split(srcString,sepString)
	fmt.Println(resultString)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 结果

[10 10 239 58]
1

2）SplitN() 切割字串分成N段（不含分隔符）

语法

func SplitN(s, sep string, n int) []string
1

用sep切割字串s，从左往右切割成N段，结果不含分隔符sep。

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	srcString := "10.10.239.58"
	sepString := "."
	resultString := strings.SplitN(srcString,sepString,3)
	fmt.Println(resultString)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 结果

[10 10 239.58]
1

3）SplitAfter() 切割字串（含分隔符）

语法

func SplitAfter(s, sep string) []string
1

用sep切割字串，每段结果包含切割符sep。

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	srcString := "10.10.239.58"
	sepString := "."
	resultString := strings.SplitAfter(srcString,sepString)
	fmt.Println(resultString)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 结果

[10. 10. 239. 58]
1

4）SplitAfterN() 切割字串分成N段（包含切割符）

语法

func SplitAfterN(s, sep string, n int) []string
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	srcString := "10.10.239.58"
	sepString := "."
	resultString := strings.SplitAfterN(srcString,sepString,3)
	fmt.Println(resultString)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 结果

[10. 10. 239.58]
1

6. 拼接函数

1）Join() 字串拼接

语法

func Join(a []string, sep string) string
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	Strings := []string{"2022","07","27"}
	sepString := "-"
	resultString := strings.Join(Strings,sepString)
	fmt.Println(resultString)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 结果

2022-07-27r
1

2）Replace() 复制副本

语法

func Replace(s, old, new string, n int) string
1

示例

package main
import (
	"fmt"
	"strings"
)

func main() {
	srcString := "liuBei@"
	dstString := strings.Repeat(srcString,3)
	fmt.Println(dstString)
}
1
2
3
4
5
6
7
8
9
10
11

显示

liuBei@liuBei@liuBei@
1

7. Reader的方法

7.1 NewReader() 创建结构体指针

语法

func NewReader(s string) *Reader
1

7.2 Len() 字串长度

语法

func (r *Reader) Len() int
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	reader := strings.NewReader("liuBei")
	num := reader.Len()
	fmt.Println(num)
}
1
2
3
4
5
6
7
8
9
10
11
12

• 结果

6
1

7.3 Read() 从*Reader中读取数据

语法

func (r *Reader) Read(b []byte) (n int, err error)
1

用b接收*Reader中的数据，返回接收的字符数和err

示例1

package main

import (
	"fmt"
	"strings"
)

func main(){
	b := make([]byte,10)
	reader := strings.NewReader("liuBei")
	num,_ := reader.Read(b)
	fmt.Println(num)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 结果

6
1

b有10个字节的位置，*Reader中有6个字节，因此可以全部被b接收。num的结果验证了以上。

示例2

package main

import (
	"fmt"
	"strings"
)

func main(){
	b := make([]byte,4)
	reader := strings.NewReader("liuBei")
	num,_ := reader.Read(b)
	fmt.Println(num)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 结果

4
1

b有4个字节的位置，*Reader中有6个字节，因此b只能接收4个字节。num的结果验证了以上。

示例3

package main

import (
	"fmt"
	"strings"
)

func main(){
	b1 := make([]byte,4)
	b2 := make([]byte,10)
	reader := strings.NewReader("liuBei")
	num1,_ := reader.Read(b1)
	num2,_ := reader.Read(b2)
	fmt.Printf("num1：%d\nnum2：%d\n",num1,num2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 结果

num1：4
num2：2
1
2

可见，reader中有6个字节的数据，其中b1接收了4个字节的数据，b2接收了剩下的2个字节的数据。

7.4 ReadByte() 每次单字节读

byte接收读的结果，显然读不了一个汉字，只能读一个英文字母或英文字符。

语法

func (r *Reader) ReadByte() (b byte, err error)
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	reader := strings.NewReader("liuBei")

	for {
		myByte,_ := reader.ReadByte()
		if myByte == 0 {
			break
		}
		fmt.Println(string(myByte),myByte,len(string(myByte)))
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 结果

l 108 1
i 105 1
u 117 1
B 66 1
e 101 1
i 105 1
1
2
3
4
5
6

7.5 UnreadByte() 退回一个字节

语法

回退一个字节，将已读计数的值减一

func (r *Reader) UnreadByte() error
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	reader := strings.NewReader("liuBei")
	result,_ := reader.ReadByte()
	fmt.Printf("第一次读到：%q\n",string(result))
	err := reader.UnreadByte()
	if err !=nil {
		fmt.Println(err)
	}else {
		fmt.Println("退回一个字节，已读计数 -1 ")
	}
	result,_ = reader.ReadByte()
	fmt.Printf("第二次读到：%q\n",string(result))

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

结果输出

第一次读到："l"
退回一个字节，已读计数 -1 
第二次读到："l"
1
2
3

示例

在开始处退1字节报错如下

import (
	"fmt"
	"strings"
)

func main(){

	reader := strings.NewReader("liuBei")
	err := reader.UnreadByte()
	if err !=nil {
		fmt.Println(err)
	}else {
		fmt.Println("退回一个字节，已读计数 -1 ")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 结果

strings.Reader.UnreadByte: at beginning of string
1

7.6 ReadRune() 每次读一个符号

rune 实际是 int32，因此可以读到一个完整的汉字（一个汉字3个字符，即24位）。而之前的ReadByte 是用int8 接收，显然不能接收一个完整汉字。

语法

func (r *Reader) ReadRune() (ch rune, size int, err error)
1

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	reader := strings.NewReader("刘备刘玄德")

	for {
		myByte,size,_ := reader.ReadRune()
		if myByte == 0 {
			break
		}
		fmt.Println(string(myByte),myByte,size)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

刘 21016 3
备 22791 3
刘 21016 3
玄 29572 3
德 24503 3
1
2
3
4
5

7.7 UnreadRune() 退一个字符

语法

func (r *Reader) UnreadRune() error
1

示例

import (
	"fmt"
	"strings"
)

func main(){
	reader := strings.NewReader("刘备刘玄德")
	result,size,_ := reader.ReadRune()
	fmt.Printf("第一次读到：%q，  字节数：%d\n",string(result),size)
	err := reader.UnreadRune()
	if err !=nil {
		fmt.Println(err)
	}else {
		fmt.Println("退回一个字符，已读计数 -1 ")
	}
	result,size,_ = reader.ReadRune()
	fmt.Printf("第二次读到：%q，  字节数：%d\n",string(result),size)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 结果

第一次读到："刘"，  字节数：3
退回一个字符，已读计数 -1 
第二次读到："刘"，  字节数：3
1
2
3

7.8 Seek() 设置读取偏移量

语法

func (r *Reader) Seek(offset int64, whence int) (int64, error)
1

• offset，偏移量。
• whence，起始位置。

示例

如下，不管读到哪了，我们设置初始位置是1，且偏移是3，则读取位置到了4。
此时我们再读，预期会读到字母e

package main

import (
	"fmt"
	"strings"
)

func main(){
	reader := strings.NewReader("liuBei")
	result,size,_ := reader.ReadRune()
	fmt.Printf("第一次读到：%q，  字节数：%d\n",string(result),size)
	//result,size,_ = reader.ReadRune()
	//fmt.Printf("第一次读到：%q，  字节数：%d\n",string(result),size)
	sit,_ := reader.Seek(3,1)
	fmt.Printf("退回到位置： %d\n",sit)
	result,size,_ = reader.ReadRune()
	fmt.Printf("第二次读到：%q，  字节数：%d\n",string(result),size)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 结果

第一次读到："l"，  字节数：1
退回到位置： 4
第二次读到："e"，  字节数：1
1
2
3

7.9 ReadAt() 从指定位置额外读取

语法

func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
1

• off，起始位置。
• b，接收读取的数据

注意：ReadAt不改变读取计数值。

示例

package main

import (
	"fmt"
	"strings"
)

func main(){
	reader := strings.NewReader("liuBei")
	myBytes := make([]byte,4)
	//设置起始位置是4，用myBytes接收读取结果
	sit,_ := reader.ReadAt(myBytes,4)
	fmt.Printf("读取到的结果为：%q，读取到字节说为：%d\n",string(myBytes),sit)
	//验证ReadAt不会改变读取计数值：再次读取，仍然是0位
	myRead,_ := reader.ReadByte()
	fmt.Printf("再次读取，结果为：%q ,说明读取计数没有被ReadAt改变。",string(myRead))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 结果

读取到的结果为："ei\x00\x00"，读取到字节说为：2
再次读取，结果为："l" ,说明读取计数没有被ReadAt改变。
1
2

7.10 Reset() 重新设置字串

语法

func (r *Reader) Reset(s string)
1

示例

package main

import (
	"fmt"
	"strings"
)

func main() {
	reader := strings.NewReader("关羽")
	result,num,_ := reader.ReadRune()
	fmt.Println(string(result),result,num)

	reader.Reset("武圣")
	result,num,_ = reader.ReadRune()
	fmt.Println(string(result),result,num)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 结果

关 20851 3
武 27494 3
1
2

8. Replacer 接口

8.1 NewReplacer() 初始化 *Replacer

语法

func NewReplacer(oldnew ...string) *Replacer
1

8.2 Replace() 替换

语法

func (r *Replacer) Replace(s string) string
1

示例

import (
	"fmt"
	"strings"
)

func main() {
	replacer := strings.NewReplacer("-",":",":","-")
	result := replacer.Replace("2022-07-20 15:39")
	fmt.Println(result)
}
1
2
3
4
5
6
7
8
9
10

• 结果

2022:07:20 15-39
1

---