strings包

合集 - 【SDK卷】-----------------------------(24)

1.strings包2022-07-30

2.envconfig包（读取环境变量）2022-05-12 3.gocron包（定时任务）2023-01-04 4.go-redis包2023-03-14 5.net/http包实战2022-05-02 6.net/http包Client的使用2022-05-10 7.01-判断正则匹配、判断正则合法性2022-06-18 8.02-查找正则匹配字串、查找正则匹配字串的位置2022-06-19 9.03-查找匹配字串，查找匹配字串位置，正则分组2022-06-20 10.04-使用正则替换2022-06-22 11.06-其他用法2022-06-25 12.01-注释、作用域、空格和空行、管道2022-08-29 13.02-变量、if语句、迭代、内置函数2022-08-31 14.01-入门示例、工作簿、文件Writer2022-09-04 15.02-工作表操作2022-09-08 16.03-行和列操作2022-09-13 17.04-迭代器2022-09-16 18.05-单元格操作2022-09-27 19.06-样式设置2022-09-29 20.07-流式写入2022-10-21 21.01-Gauge（仪表盘）2022-08-08 22.02-Counter（计数器）2022-08-09 23.03-HIstogram（直方图）2022-08-22 24.04-Summary（摘要）2022-08-21

1. 判断字串函数
2. 统计函数
3. 大小写转换函数
4. 裁切函数
5. 切割函数
6. 拼接函数
- 1）Join() 字串拼接
  - 语法
  - 示例
- 2）Replace() 复制副本
  - 语法
  - 示例
7. Reader的方法
8. Replacer 接口

1. 判断字串函数

1）EqualFold() 判断字串相等

语法

 func EqualFold(s string, t string) bool

示例

 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)
	}
}

输出

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

示例（不区分大小写）

 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)
	}
}

输出

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

2）HasPrefix() 判断前缀

语法

 func HasPrefix(s string, prefix string) bool

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德"
	preString := "刘"
	if strings.HasPrefix(srcString,preString){
		fmt.Println("Yes")
  }else{
	  fmt.Println("No")
	}
}

输出

Yes

3）HasSuffix() 判断后缀

语法

 func HasSuffix(s, suffix string) bool

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德"
	preString := "玄德"
	if strings.HasSuffix(srcString,preString){
		fmt.Println("Yes")
  }else{
	  fmt.Println("No")
	}
}

输出

Yes

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

语法

 func Contains(s, substr string) bool

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "《咏怀古迹·诸葛大名垂宇宙》"
	subString := "诸葛"
	if strings.Contains(srcString,subString){
		fmt.Println("Yes")
	}else {
		fmt.Println("No")
	}
}

输出

Yes

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

语法

 func ContainsRune(s string, r rune) bool

判断字符串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")
	}
}

输出

Yes

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

语法

 func ContainsAny(s, chars string) bool

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

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德"
	charString := "刘关张"
	if strings.ContainsAny(srcString,charString){
		fmt.Println("Yes")
	}else {
		fmt.Println("No")
	}
}

输出

Yes

2. 统计函数

1） Count() 统计出现次数

语法

 func Count(s, sep string) int

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

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德"
	sepString := "刘"
 
	num := strings.Count(srcString,sepString)
	fmt.Println(num)
}

输出

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

语法

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

 func Index(s, sep string) int

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德"
	sepString := "备"
 
	num := strings.Index(srcString,sepString)
	fmt.Println(num)
}

输出

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

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

语法

 func IndexByte(s string, c byte) int

示例

 package main
 
import (
	"fmt"
	"strings"
)
 
func main(){
	srcString := "liuBei"
	myByte := byte('e')
	site := strings.IndexByte(srcString,myByte)
	fmt.Println(site)
}

输出

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

语法

 func IndexRune(s string, r rune) int

示例

 package main
 
import (
	"fmt"
	"strings"
)
 
func main(){
	srcString := "liuBei"
	site := strings.IndexRune(srcString,'B')
	fmt.Println(site)
}

结果输出

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

语法

 func IndexAny(s, chars string) int

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

示例

 package main
 
import (
	"fmt"
	"strings"
)
 
func main(){
	srcString := "功盖三分国，名成八阵图"
	charsString := "二五八"
	site := strings.IndexAny(srcString,charsString)
	fmt.Println(site)
}

结果

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

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

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

语法

 func LastIndex(s, sep string) int

示例

 package main
 
import (
	"fmt"
	"strings"
)
 
func main(){
	srcString := "刘备刘玄德"
	sepString := "刘"
	site := strings.LastIndex(srcString, sepString)
	fmt.Println(site)
}

结果

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

语法

 func LastIndexAny(s, chars string) int

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

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德"
	charsString := "刘关张"
	site := strings.LastIndexAny(srcString,charsString)
	fmt.Println(site)
}

结果

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

3. 大小写转换函数

1）Title( ) 转换为标题

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

语法

 func Title(s string) string

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "hello worlD"
	titleString := strings.Title(srcString)
	fmt.Println(titleString)
}

-输出

 Hello WorlD

词首变成大写

后边的大写不会变成小写

2）ToTitle() 全文转标题

语法

 func ToTitle(s string) string

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "liuBei xuanDE"
	titleString := strings.ToTitle(srcString)
	fmt.Println(titleString)
}

显示

 LIUBEI XUANDE

3）ToLower() 大写转小写

语法

 func ToLower(s string) string

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "HELLO world"
	lowerString := strings.ToLower(srcString)
	fmt.Println(lowerString)
}

结果

 hello world

4）ToUpper() 小写转大写

语法

 func ToUpper(s string) string

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "HELLO world"
	upperString := strings.ToUpper(srcString)
	fmt.Println(upperString)
}

输出

 hello world

4. 裁切函数

1）Trim() 首尾裁切字串

语法

裁切掉s头尾的cutset字串

 func Trim(s string, cutset string) string

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德刘"
	cutString := "刘"
	resultString := strings.Trim(srcString,cutString)
	fmt.Println(resultString)
}

结果

 备刘玄德

头尾的刘字同时被剪切

2）TrimSpace() 首尾裁切空白

语法

 func TrimSpace(s string) string

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "   关羽关云长"
	resultString := strings.TrimSpace(srcString)
	fmt.Printf("源字串： %q\n裁切后： %q\n", srcString,resultString)
}

结果

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

3）TrimLeft() 只裁左侧

语法

 func TrimLeft(s string, cutset string) string

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德刘"
	cutString := "刘"
	resultString := strings.TrimLeft(srcString,cutString)
	fmt.Println(resultString)
}

结果

 备刘玄德刘

4）TrimPrefix() 裁切头部

语法

 func TrimPrefix(s, prefix string) string

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德"
	cutString := "刘备"
	resultString := strings.TrimPrefix(srcString,cutString)
	fmt.Println(resultString)
}

结果

 刘玄德

5）TrimRight() 右侧裁切

语法

 func TrimRight(s string, cutset string) string

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "刘备刘玄德"
	cutString := "玄德"
	resultString := strings.TrimRight(srcString,cutString)
	fmt.Println(resultString)
}

结果

 刘备刘

6）TrimSuffix() 尾部裁切

语法

 func TrimSuffix(s, suffix string) string

示例

 package main
 
import (
	"fmt"
	"strings"
)
 
func main(){
	srcString := "刘备刘玄德"
	cutString := "玄德"
	resultString := strings.TrimSuffix(srcString,cutString)
	fmt.Println(resultString)
}

输出

 刘备刘

5. 切割函数

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

语法

 func Split(s, sep string) []string

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

示例

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

结果

 [10 10 239 58]

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

语法

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

用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)
}

结果

 [10 10 239.58]

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

语法

 func SplitAfter(s, sep string) []string

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

示例

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

结果

 [10. 10. 239. 58]

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

语法

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

示例

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

结果

 [10. 10. 239.58]

6. 拼接函数

1）Join() 字串拼接

语法

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

示例

 package main
 
import (
	"fmt"
	"strings"
)
 
func main(){
	Strings := []string{"2022","07","27"}
	sepString := "-"
	resultString := strings.Join(Strings,sepString)
	fmt.Println(resultString)
}

结果

 2022-07-27r

2）Replace() 复制副本

语法

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

示例

 package main
import (
	"fmt"
	"strings"
)
 
func main() {
	srcString := "liuBei@"
	dstString := strings.Repeat(srcString,3)
	fmt.Println(dstString)
}

显示

 liuBei@liuBei@liuBei@

7. Reader的方法

7.1 NewReader() 创建结构体指针

语法

 func NewReader(s string) *Reader

7.2 Len() 字串长度

语法

 func (r *Reader) Len() int

示例

 package main
 
import (
	"fmt"
	"strings"
)
 
func main(){
	reader := strings.NewReader("liuBei")
	num := reader.Len()
	fmt.Println(num)
}

结果

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

语法

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

用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)
}

结果

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)
}

结果

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)
}

结果

 num1：4
num2：2

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

7.4 ReadByte() 每次单字节读

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

语法

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

示例

 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)))
	}
}

结果

7.5 UnreadByte() 退回一个字节

语法

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

 func (r *Reader) UnreadByte() error

示例

 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))
 
}

结果输出

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

示例

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

 import (
	"fmt"
	"strings"
)
 
func main(){
 
	reader := strings.NewReader("liuBei")
	err := reader.UnreadByte()
	if err !=nil {
		fmt.Println(err)
	}else {
		fmt.Println("退回一个字节，已读计数 -1 ")
	}
}

结果

 strings.Reader.UnreadByte: at beginning of string

7.6 ReadRune() 每次读一个符号

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

语法

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

示例

 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)
	}
}

7.7 UnreadRune() 退一个字符

语法

 func (r *Reader) UnreadRune() error

示例

 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)
 
}

结果

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

7.8 Seek() 设置读取偏移量

语法

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

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)
 
}

结果

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

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

语法

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

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))
}

结果

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

7.10 Reset() 重新设置字串

语法

 func (r *Reader) Reset(s string)

示例

 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)
}

结果

 关 20851 3
武 27494 3

8. Replacer 接口

8.1 NewReplacer() 初始化 *Replacer

语法

 func NewReplacer(oldnew ...string) *Replacer

8.2 Replace() 替换

语法

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

示例

 import (
	"fmt"
	"strings"
)
 
func main() {
	replacer := strings.NewReplacer("-",":",":","-")
	result := replacer.Replace("2022-07-20 15:39")
	fmt.Println(result)
}

结果

 2022:07:20 15-39

posted on 2022-07-30 22:12 运维开发玄德公阅读(14) 评论(0) 编辑收藏举报来源

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 02-查找正则匹配字串、查找正则匹配字串的位置

· 03-查找匹配字串，查找匹配字串位置，正则分组

· go strings包

· Go-秘籍-全-

· [Go语言tips06]浅谈strings包

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了

	l 108 1
	i 105 1
	u 117 1
	B 66 1
	e 101 1
	i 105 1

	刘 21016 3
	备 22791 3
	刘 21016 3
	玄 29572 3
	德 24503 3

	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)
	}
	}

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

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

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

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

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