1. 字节数组
字节与字符的区别
- 字节(Byte) 是计量单位，表示数据量多少，是计算机信息技术用于计量存储容量的一种计量单位，通常情况下一字节等于八位
- 字符(Character) 是计算机中使用的字母、数字、字和符号，比如'A'、'B'、'$'、'&'等
- 一般在英文状态下一个字母或字符占用一个字节，一个汉字用两个字节表示
- 通俗点来说，人的语言就是字符，而字节是机器的语言
示例
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
package mainimport "fmt"func main() { var ( str1 = "hello" str2 = "world" ) str3 := str1 + " " + str2 //字符串转换成字节数组 tmp := []byte(str3) fmt.Printf("数据: %s,长度: %d,数据类型: %T\n", str3, len(str3), str3) fmt.Println("字节数组:", tmp) fmt.Printf("数据: %s,长度: %d,数据类型: %T\n", tmp, len(tmp), tmp) //字节数组转字符串 fmt.Println("字节数组转字符串:", string(tmp)) //反转函数调用 fmt.Println("反转: ", Reverse(str3))}//反转函数func Reverse(str string) string { var ( result string leng int = len(str) ) for i := 0; i < leng; i++ { //sprintf转换数据类型为string,使用+进行拼接 result = result + fmt.Sprintf("%c", str[leng-i-1]) } return result} |
输出结果如下
数据: hello world,长度: 11,数据类型: string
字节数组: [104 101 108 108 111 32 119 111 114 108 100]
数据: hello world,长度: 11,数据类型: []uint8
字节数组转字符串: hello world
反转: dlrow olleh
Sprintf的作用
|
1
2
3
4
5
6
7
8
9
10
|
package mainimport "fmt"func main() { var a = 88 fmt.Printf("a的数值: %d , 类型: %T\n", a, a) b := fmt.Sprintf("%d", a) fmt.Printf("b的数值: %s , 类型: %T\n", b, b)} |
输出结果如下
a的数值: 88 , 类型: int
b的数值: 88 , 类型: string
2. 头尾处理
prefix()函数判断前缀
suffix()函数判断后缀
使用prefix函数判断URL是否是以http://为开头，如果不是，则加上http://使用suffix函数判断路径是否以/结尾，如果不是，则加上/为结尾
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
package mainimport ( "fmt" "strings")func main() { var ( url string path string ) fmt.Println("请输入URL和路径:") fmt.Scanf("%s%s", &url, &path) fmt.Printf("URL: %s\n", urlProcess(url)) fmt.Printf("路径: %s", pathProcess(path))}//字符串头部处理func urlProcess(url string) string { //判断是否以http://开头，返回布尔类型赋予result result := strings.HasPrefix(url, "http://") if !result { url = fmt.Sprintf("http://%s", url) } return url}//字符串尾部处理func pathProcess(path string) string { //判断是否以/结尾，返回布尔类型赋予result result := strings.HasSuffix(path, "/") if !result { path = fmt.Sprintf("%s/", path) } return path} |
终端输入如下：
PS D:\goproject\src\test\main> go run .\main.go
请输入URL和路径:
www.google.com /opt/conf/k8s
URL: http://www.google.com
路径: /opt/conf/k8s/
3. 位置索引
Index()函数判断出现在前面的位置
LastIndex()函数判断出现在末尾的位置
判断子字符串在字符串中首次出现的位置和在末尾出现的位置
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package mainimport ( "fmt" "strings")func main() { var ( a = "abbaabcddccd" str = "cd" ) //判断str在a中首次出现的位置 head := strings.Index(a, str) tail := strings.LastIndex(a, str) fmt.Printf("首次出现的位置:%d\n最后出现的位置:%d\n", head, tail)} |
输出结果如下
首次出现的位置:6
最后出现的位置:10
4. 替换
Replace()函数格式如下：
Replace(原字符串,原字段,新字符串,新字段,替换次数) -1表示全部替换，0表示不替换
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package mainimport ( "fmt" "strings")func main() { var ( a = "abbaabcddccd" ) //把cd替换成CD，-1表示全部替换，0表示不替换 result := strings.Replace(a, "cd", "CD", -1) fmt.Printf("替换前: %v\n", a) fmt.Printf("全部替换后: %v\n", result) result1 := strings.Replace(a, "cd", "CD", 0) fmt.Printf("不进行替换: %v\n", result1)} |
输出结果如下
替换前: abbaabcddccd
全部替换后: abbaabCDdcCD
不进行替换: abbaabcddccd
5. 统计次数
Count()函数统计次数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package mainimport ( "fmt" "strings")func main() { var a = "abbcddcedsca" count := strings.Count(a, "cd") fmt.Printf("count: %v\n", count)} |
输出结果如下
count: 1
6. 重复
Repeat()函数重复输出多次
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package mainimport ( "fmt" "strings")func main() { var a = "加油~" result := strings.Repeat(a, 3) fmt.Printf("result: %v\n", result)} |
输出结果如下
result: 加油~加油~加油~
7. 大小写
ToUpper()函数转换大写
ToLower()函数转换小写
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package mainimport ( "fmt" "strings")func main() { var a = "hello" //转换大写 result1 := strings.ToUpper(a) fmt.Printf("大写: %v\n", result1) //把上面转换的大写给转成小写 result2 := strings.ToLower(result1) fmt.Printf("小写: %v\n", result2)} |
输出结果如下
大写: HELLO
小写: hello
8. 去除字符
TrimSpace()函数去除空白字符
TrimLeft()从左往右删除
TrimRight()从右往左删除
去除首尾空白字符
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package mainimport ( "fmt" "strings")func main() { var a = " abc " fmt.Println("长度:", len(a)) //去除首位空白的字符 result1 := strings.TrimSpace(a) fmt.Println("去除首尾空白字符:", result1, "\n长度:", len(result1))} |
输出结果如下
长度: 5
去除首尾空白字符: abc
长度: 3
去除指定位置字符
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package mainimport ( "fmt" "strings")func main() { var a = "this is test web" //去掉字符串首尾部web字符 result1 := strings.Trim(a, "web") fmt.Println("尾部去除:", result1) //从左往右删除所有指定的字符，直到遇到不包含在指定的字符为止 result2 := strings.TrimLeft(a, "this") //空格也需匹配删除，直到没有指定的字符可以匹配为止 result3 := strings.TrimLeft(a, "this ") //从右往左删除所有指定的字符，直到遇到不包含在内的字符为止 result4 := strings.TrimRight(a, "web") fmt.Println("从左往右删除:", result2) fmt.Println("从左往右删除,有空格:", result3) fmt.Println("从右往左删除:", result4)} |
输出结果如下
尾部去除: this is test
从左往右删除: is test web
从左往右删除,有空格: est web
从右往左删除: this is test
9. 字符串切片处理
Fields()函数
Split()函数
默认识别空格进行切片处理
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package mainimport ( "fmt" "strings")func main() { var str string = "abc def ghi" //Fields函数默认识别的符号是空格 result1 := strings.Fields(str) fmt.Printf("数据类型: %T , 数据格式: %v\n", result1, result1) for i := 0; i < len(result1); i++ { fmt.Println(result1[i]) }} |
输出结果如下
数据类型: []string , 数据格式: [abc def ghi]
abc
def
ghi
识别其他符号分隔成切片
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package mainimport ( "fmt" "strings")func main() { var str string = "abc,def,ghi" //识别逗号进行分隔切片 result := strings.Split(str, ",") fmt.Printf("数据类型: %T , 数据格式: %v\n", result, result)} |
输出结果如下
数据类型: []string , 数据格式: [abc def ghi]
推荐使用Split()函数进行分隔
因为fields()函数默认只能识别空格，不能识别其他符号，而Split()函数则均可以识别
把切片按指定分隔符进行转换成字符串
Join()函数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
package mainimport ( "fmt" "strings")func main() { //定义切片 var slice = []string{"123", "456", "789"} fmt.Printf("切片: %v\n", slice) //切片转换成字符串 result := strings.Join(slice, ":") fmt.Printf("数据结构: %v , 数据类型: %T", result, result)} |
输出结果如下
切片: [123 456 789]
数据结构: 123:456:789 , 数据类型: string
10. 数值处理
使用strconv.Itoa()函数将数值转换成字符串
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package mainimport ( "fmt" "strconv")func main() { var num int = 12345678 fmt.Printf("初始数据类型: %T\n", num) fmt.Printf("初始值: %d\n", num) //转换成字符串 result := strconv.Itoa(num) fmt.Printf("转换后数据类型: %T\n", result) fmt.Printf("转换后值为: %s", result)} |
输出结果如下
初始数据类型: int
初始值: 12345678
转换后数据类型: string
转换后值为: 12345678
使用Sprintf()函数将整数转换成字符串
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package mainimport ( "fmt")func main() { var num int = 12345678 fmt.Printf("初始数据类型: %T\n", num) //使用Sprintf()转换成字符串，可以实现多类型的转换 result := fmt.Sprintf("%d", num) fmt.Printf("转换后数据类型:%T\n", result)} |
输出结果如下
初始数据类型: int
转换后数据类型:string
使用strconv.Atoi()函数进行字符串转换整数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package mainimport ( "fmt" "strconv")func main() { var str string = "12345678" //字符串转整数 result, err := strconv.Atoi(str) //如果有转换过程中有错，就抛出错误，没有错就返回数据类型 if err == nil { fmt.Printf("数据类型: %T\n", result) } else { fmt.Println(err) }} |
输出结果
数据类型: int
到此这篇关于Go语言字符串常见操作的使用汇总的文章就介绍到这了,更多相关Go语言字符串操作内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://www.cnblogs.com/lvrui/p/16163108.html
