Go 语言 常用字符串函数的使用
1.统计字符串的长度，按字节len(str)：
func main() {
// 统计字符串的长度, 按字节统计len(str)
// golang 的编码统一为 utf-8, 一个英文占1个字节、一个汉字占3个字节
var myStr string = "hello北京"
fmt.Println("mystr的长度为:", len(myStr))
}
// 输出结果 11
原因：北京 占用 6个字节 + hello 五个字节 = 11个字节
2.字符串遍历，处理有中文的字符，r := []rune(str)：
// 字符串遍历， 处理含有中文字符
func main() {
myStr1 := "hello北京"
newStr := []rune(myStr1)
for i := 0; i < len(newStr); i++ {
fmt.Printf("%c\n", newStr[i])
}
}
// 输出结果：
h
e
l
l
o
北
京
3.字符串转整数：
package main
import (
"fmt"
"strconv"
)
func () {
// 字符串转整型
var myStr2 string = "12"
val, typeErr := strconv.Atoi(myStr2)
fmt.Println("val=", val , "type_err=", typeErr)
}
// 输出结果：
val= 12 type_err= <nil> // nil 表示空值
// 错误示例：
package main
import (
"fmt"
"strconv"
)
func main() {
// 字符串转整型错误示范
var myStrErr string = "hello"
value, typeErr := strconv.Atoi(myStrErr)
fmt.Println("value:", value, "typeErr", typeErr)
}
// 报错信息如下：
value: 0 typeErr strconv.Atoi: parsing "hello": invalid syntax
4.整数转字符串：
// 将整数类型 转换成字符串
package main
import (
"fmt"
"strconv"
)
func main() {
// 将整数转换成字符串
var myInt int = 666
value := strconv.Itoa(myInt)
fmt.Printf("value=%v type=%T", value, value)
}
// 输出如下：
value=666 type=string
5.字符串 转[]byte：
// 将字符串 转换成 字节
package main
import "fmt"
func main() {
// 字符串 转 []byte
myStr3 := "hello"
myByte := []byte(myStr3)
fmt.Printf("mybyte=%v", myByte)
}
// 输出结果:
mybyte=[104 101 108 108 111]
ascii 表 对应 104 = "h" 101 = "e" 108 = "l" 111 = "o"
6.[]byte 转 字符串：
// 将[]byte 转换成 字符串
package main
import "fmt"
func main() {
// []byte 转 字符串
myByte := []byte{104, 101, 108, 108, 111}
myStr := string(myByte)
fmt.Printf("str=%v", myStr)
}
// 输出结果：
str=hello
7.十进制转换2，8，16进制：
package main
import (
"fmt"
"strconv"
)
func main() {
// 进制转换 十进制 转换成 2、8、16进制
var myInt int64 = 666
result := strconv.FormatInt(myInt, 2)
fmt.Printf("666对应的二进制:=%v\n", result)
result1 := strconv.FormatInt(myInt, 8)
fmt.Printf("666对应的八进制:=%v\n", result1)
result2 := strconv.FormatInt(myInt, 16)
fmt.Printf("666对应的十六进制:=%v", result2)
}
// 输出结果：
666对应的二进制:=1010011010
666对应的八进制:=1232
666对应的十六进制:=29a
8.查找子串是否在指定的字符串中：
package main
import (
"fmt"
"strings"
)
func main() {
// 检查 子串 是否在 指定的字符串中
childStr := "abc"
myStr := "abcdefg"
result := strings.Contains(myStr, childStr)
fmt.Printf("结果为:%v, 返回的类型为：%T", result, result)
}
// 输出结果：
结果为:true, 返回的类型为：bool
9.统计一个字符串中有几个指定的字符：
package main
import (
"fmt"
"strings"
)
func main() {
// 统计一个字符串中有几个指定的字符
myStr := "hello"
result := strings.Count(myStr, "l")
fmt.Printf("myStr中出现l的字符个数为:%v", result)
}
// 输出结果:
myStr中出现l的字符个数为:2
10.不区分大小写的字符串比较:
package main
import (
"fmt"
"strings"
)
func main() {
// 不区分大小写字符串的比较
myStr := "abc"
myStr1 := "ABC"
result := strings.EqualFold(myStr, myStr1)
fmt.Printf("结果：%v\n", result)
// == 号 是区分大小写的比较
fmt.Println("结果:", myStr1 == myStr)
}
// 输出结果：
结果：true
结果: false
11.查找子串在字符串第一次出现的 index 值，若没有返回 -1:
package main
import (
"fmt"
"strings"
)
func main() {
// 返回子串在字符串第一次出现的index 值, 如果没有返回 -1
myStr := "fe_cow"
index := strings.Index(myStr, "w")
fmt.Printf("index=%v", index)
}
// 输出结果：
index=5
如果没有找到: 返回 -1
12.查找子串在字符串最后一次出现的index，若没有返回 -1：
package main
import (
"fmt"
"strings"
)
func main() {
// 返回子串在字符串中 最后一次出现的index值, 如果没有返回 -1
myStr := "fe_cow_fe_cow"
index := strings.LastIndex(myStr, "w")
fmt.Printf("index=%v", index)
}
// 输出结果：
index=12
13.字符串的替换：
n = -1 表示全部替换;
package main
import (
"fmt"
"strings"
)
func main() {
// 字符串的替换 n = -1 表示全部替换
myStr := "python python java go"
result := strings.Replace(myStr, "python", "django", -1)
fmt.Printf("myStr=%v\nresult=%v", myStr, result)
}
// 输出结果：
myStr=python python java go
result=django django java go
14.字符串的拆分：
一个字符串拆分成字符串数组;
package main
import (
"fmt"
"strings"
)
func main() {
// 字符串的拆分
myStr := "hello world golang"
// 根据空格进行拆分
strArr := strings.Split(myStr, " ")
for i:= 0; i < len(strArr); i ++{
fmt.Printf("str[%v]=%v\n", i, strArr[i])
}
fmt.Printf("strArr=%v", strArr)
}
// 输出结果：
str[0]=hello
str[1]=world
str[2]=golang
strArr=[hello world golang]
15.字符串的大小写转换：
package main
import (
"fmt"
"strings"
)
func main() {
// 字符串大小写的转换
myStr := "HELLO golang"
lowerStr := strings.ToLower(myStr)
fmt.Printf("转换小写=%v\n", lowerStr)
upperStr := strings.ToUpper(myStr)
fmt.Printf("转换大写=%v", upperStr)
}
// 输出结果：
转换小写=hello golang
转换大写=HELLO GOLANG
16.去掉字符串左右两边空格：
package main
import (
"fmt"
"strings"
)
func main() {
// 去掉字符串左右两边的空格
myStr := " hello "
fmt.Printf("原字符串的长度为:%d\n", len(myStr))
newStr := strings.TrimSpace(myStr)
fmt.Printf("去除了左右两边的空格:%v, 字符串长度:%d", newStr, len(newStr))
}
// 输出结果：
原字符串的长度为:9
去除了左右两边的空格:hello, 字符串长度:5
17.去掉字符串左右两边指定的字符：
package main
import (
"fmt"
"strings"
)
func main() {
// 去掉字符串左右两边的指定字符
myStr := "!hello!"
newStr := strings.Trim(myStr, "!")
fmt.Printf("去掉指定字符两边指定字符:%v", newStr)
}
// 输出结果：
去掉指定字符两边指定字符:hello
18.去掉字符串左边指定的字符：
package main
import (
"fmt"
"strings"
)
func main() {
// 去掉字符串左边指定的字符
myStr := "hello python"
newStr := strings.TrimLeft(myStr, "hello")
fmt.Printf("去掉左边指定的字符:%v", newStr)
}
// 输出结果：
去掉左边指定的字符: python
19.去掉字符串右边指定的字符：
package main
import (
"fmt"
"strings"
)
func main() {
// 去掉字符串右边指定的字符
myStr := "hello django"
newStr := strings.TrimRight(myStr, "django")
fmt.Printf("去掉字符串右边指定的字符:%v", newStr)
}
// 输出结果：
去掉字符串右边指定的字符:hello
20.判断字符串是否以指定字符开头：
package main
import (
"fmt"
"strings"
)
func main() {
// 判断字符串, 是否以指定的字符进行开头
myStr := "hello golang"
boolStr := strings.HasPrefix(myStr, "hello")
fmt.Printf("判断字符串, 是否以指定的字符进行开头:%v", boolStr)
}
// 输出结果：
判断字符串, 是否以指定的字符进行开头:true
21.判断字符串是否以指定的字符结束：
package main
import (
"fmt"
"strings"
)
func main() {
// 判断字符串, 是否以指定的字符结束, 返回值 布尔类型
myStr := "hello python"
boolStr := strings.HasSuffix(myStr, "python")
fmt.Printf("是否以指定的字符结束:%v", boolStr)
}
// 输出结果：
是否以指定的字符结束:true
