go数据类型转换和字符串处理
go数据类型转换和字符串处理
go数据类型转换和字符串处理
数据类型转换和字节数组
数据类型(表达式)如:
- string(abc) :将abc 转换为string类型
- []byte(abc): 将abc 转换为 字节类型，组成字节数组
- float32(1):将 1 转换为32位浮点型
package main
import "fmt"
func main() {
var (
str1 = "hello"
str2 = "world"
)
result := str1 + " " + str2
fmt.Printf("数据%s,长度:%d,数据类型:%T\n", result, len(result), result)
//字符串转换成字节数组
tmp := []byte(result)
fmt.Printf("tmp数据%s,长度:%d,数据类型:%T\n", tmp, len(tmp), tmp)
for i := 0; i < len(tmp); i++ {
//字节 转字符
fmt.Println(string(tmp[i]))
// a := len(tmp) - 1 - i
// fmt.Println(string(tmp[a]))
}
fmt.Println(string(tmp))
fmt.Println("反转:", Revers(result))
}
//反转函数
func Revers(str string) string {
var (
result string
leng int = len(str)
)
for i := leng - 1; i >= 0; i-- {
//sprintf转换数据类型为string，使用 + 进行拼接
result = result + fmt.Sprintf("%c", str[i])
}
return result
}
//输出结果:
数据hello world,长度:11,数据类型:string
tmp数据hello world,长度:11,数据类型:[]uint8
h
e
l
l
o
w
o
r
l
d
hello world
反转: dlrow olleh
通过修改单个字符元素，将hello world 修改为Hello World
//通过修改单个字符元素，将hello world 修改为Hello World
package main
import (
"fmt"
)
func main() {
var str1 string = "hello world"
//将字符串类型转换为字节数组，并赋值给tmp
tmp := []byte(str1)
//tmp值是一个由对应字符组成的ASCll码 数组。
//将数组第一个值修改为 "H" 对应的ASCll码
tmp[0] = 72
fmt.Println("第一次修改后的数据是:", string(tmp))
//遍历字节数组
for i := 0; i < len(tmp); i++ {
//使用string 将字节转为字符。当转变后的字符为小写w时，将其重新赋值为大写W
if string(tmp[i]) == "w" {
//注意，这里使用单引号，表示 rune类型
tmp[i] = 'W'
}
}
fmt.Println("第二次修改后的数据是:", string(tmp))
//输出结果:
修改后的数据是: Hello world
修改后的数据是: Hello World
使用 fmt.Sprintf(格式化字符串类型,字符串) 将任何数据转换为string 类型
package main
import "fmt"
func main() {
var num = 10
fmt.Printf("num的类型是:%T \n", num)
ref := fmt.Sprintf("%d", num)
fmt.Printf("num的类型是:%T", ref)
}
//输出结果:
num的类型是:int
num的类型是:string
注意，go 不支持隐式转换类型
package main
import "fmt"
func main() {
var a int64 = 10
var b int32 = 20
//此时，有与ab的数值类型不同，直接交换会报错
a = b
fmt.Printf("b为%d", b)
}
此时执行则报错
cannot use a (type int64) as type int32 in assignment
修改后:
package main
import "fmt"
func main() {
var a int64 = 10
var b int32 = 20
//需要将a转换为int32，再交换
b = int32(a)
fmt.Printf("b为%d", b)
}
//输出结果:
b为10
头尾处理
strings.HasPrefix(字符串,关键字) 判断字符串是否以关键字为开头。 返回值为 bool类型
strings.HasSuffix(字符串,关键字)判断字符串是否以关键字为结尾。返回值为bool类型
判断URL是否以 "http://" 开头。如果不是，则加上"http://"
判断路径是否以 "/" 结尾，如果不是，则加上 "/" 为结尾
package main
import (
"fmt"
"strings"
)
func main() {
var (
url string
path string
)
//输入两个值
fmt.Scanf("%s%s", &url, &path)
fmt.Println(urlProcess(url))
fmt.Println(pathProcess(path))
}
//头部判断是否包含 http:// ，如果不包含，则加上http://
func urlProcess(url string) string {
//返回的resutl 类型是 bool类型
result := strings.HasPrefix(url, "http://")
if !result {
url = fmt.Sprintf("http://%s", url)
}
return url
}
//尾部：判断是否包含 / ,如果不包含，则加上 /
func pathProcess(path string) string {
//返回的resutl 类型是 bool类型
result := strings.HasSuffix(path, "/")
if !result {
path = fmt.Sprintf("%s/", path)
}
return path
}
位置索引
判断字符串在字符串中首次出现的位置 strings.Index(字符串,关键字)
末尾出现的位置strings.LastIndex(字符串,关键字)
package main
import (
"fmt"
"strings"
)
//判断关键字段在字符串中出现的索引位置
func main() {
var (
s string = "abbacddccd"
str string = "cd"
)
start := strings.Index(s, str)
fmt.Println("关键词首部出现的位置：", start)
end := strings.LastIndex(s, str)
fmt.Println("关键词尾部出现的位置：", end)
}
//输出结果:
关键词首部出现的位置： 4
关键词尾部出现的位置： 8
替换
strings.Replace(原始字符串,原字段,新字段,替换次数) 替换次数小于0，如-1 ，则表示全文所有匹配都替换
package main
import (
"fmt"
"strings"
)
//替换
func main() {
var (
s string = "abbacddccdabcd"
str string = "cd"
)
//替换Replace(原始字符串,原字段,新字段,替换次数),-1(小于0的整数)表示全文替换,0表示不替换
//从左向右,替换1次
result1 := strings.Replace(s, str, "CD", 1)
fmt.Println("替换字符串：", result1)
//从左向右,替换2次
result2 := strings.Replace(s, str, "CD", 2)
fmt.Println("替换字符串：", result2)
//全文替换
result3 := strings.Replace(s, str, "CD", -1)
fmt.Println("替换字符串：", result3)
}
//输出结果:
替换字符串： abbaCDdccdabcd
替换字符串： abbaCDdcCDabcd
替换字符串： abbaCDdcCDabCD
统计次数
strings.Count(字符串,关键字) 统计关键字在字符串里出现的次数
package main
import (
"fmt"
"strings"
)
func main() {
var (
s string = "abbacddccdabcd"
str string = "cd"
)
//使用count 统计关键字出现的次数
count := strings.Count(s, str)
fmt.Println("cd出现的次数", count)
}
//输出结果:
cd出现的次数 3
复制
strings.Repeat(字符串,n次)将字符串连续复制n次
package main
import (
"fmt"
"strings"
)
//复制
func main() {
var str string = "abc"
//复制关键字段3次，相连后，并返回完整字符串
result := strings.Repeat(str, 3)
fmt.Println(result)
}
//输出结果:
abcabcabc
大小写
strings.ToUpper(字符串) 将字符串字母大写
strings.ToLower(字符串) 将字符串 字母小写
package main
import (
"fmt"
"strings"
)
//字符串大小写
func main() {
var str string = "abc"
//字符串变大写
result1 := strings.ToUpper(str)
fmt.Println("大写:", result1)
//字符串变小写
result2 := strings.ToLower(result1)
fmt.Println("小写:", result2)
}
//输出结果:
大写: ABC
小写: abc
去除字符
strings.Trimspace(字符串) 去除字符串首尾空格
strings.Trim(字符串,匹配字) 去除字符串首尾的匹配字
strings.TrimLeft(字符串,关键字)从左往右开始去除关键字，直到第一个不匹配关键字的为止（空格参与匹配）
strings.TrimRight(字符串,关键字)从右往左开始去除有关键字，直到第一个不匹配关键字的为止（空格参与匹配）
package main
import (
"fmt"
"strings"
)
//去除指定字符
func main() {
var s string = " abc "
var s1 string = "web this is web abc web"
var s2 string = "this is c abc this isc abc\tweb"
fmt.Println("原长度", len(s))
//去除首尾空格
result1 := strings.TrimSpace(s)
fmt.Printf("现长度:%d,内容:%s\n", len(result1), result1)
//去除首尾匹配关键字
result2 := strings.Trim(s1, "web")
fmt.Println("Trim处理后的字符串:", result2)
//TrimLeft()
//从左匹配关键字符，进行删除，直到没有匹配上的字符为止。即使后面有匹配字符，也不会被删除
//注意，空格也是字符
fmt.Println("TrimLeft处理前:", s2)
result3 := strings.TrimLeft(s2, " thisc")
fmt.Println("TrimLeft处理后:", result3)
//TrimRight()
//从右匹配关键字符，进行删除，直到没有匹配上的字符为止。即使后面有匹配字符，也不会被删除
//注意空格也是字符.制表符\t和空格不是
result4 := strings.TrimRight(s2, "\tcweb")
fmt.Println("TrimRitht处理结果:", result4)
}
//输出结果:
原长度 6
现长度:3,内容:abc
Trim处理后的字符串: this is web abc
TrimLeft处理前: this is c abc this isc abc web
TrimLeft处理后: abc this isc abc web
TrimRitht处理结果: this is c abc this isc a
切片处理
实例:字符串以空格分隔 转成切片
package main
import (
"fmt"
"strings"
)
//字符串切片处理
func main() {
var str string = "abc def ghi"
//Fieds函数识别的符号时空格
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
以其他字符为分隔符的
package main
import (
"fmt"
"strings"
)
func main() {
//split识别其他特殊符号分隔
var str string = "abc:def:ghi"
result1 := strings.Split(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
合并字符串。
替换字符串的分隔符
package main
import (
"fmt"
"strings"
)
func main() {
//split识别其他特殊符号分隔
var str string = "abc def ghi"
result1 := strings.Split(str, " ")
fmt.Printf("数据类型是%T,数据格式%v\n", result1, result1)
//把切片按照指定分隔符，合并车字符串
str2 := strings.Join(result1, ",")
fmt.Printf("数据类型是%T,数据格式%v\n", str2, str2)
}
数值处理
使用strconv.Itoa数值转化为字符串,使用trconv.Atoi将字符串转为数值
package main
import (
"fmt"
"strconv"
)
func main() {
var num int = 123456
var str string = "123"
fmt.Printf("num的数据类型是:%T\n", num)
fmt.Printf("str的数据类型是:%T\n", str)
fmt.Println("-------")
//数值转为字符
result1 := strconv.Itoa(num)
fmt.Printf("result1的数据类型是:%T\n", result1)
fmt.Println("--------")
//字符转为数值(字符需要是 1234这种数字类型的字符串)
//atoi 转换后，会出现两个值，一个是转换后的值，一个是error，用于抛出错误信息。
//如果转换成功，error 值为空。
result2, err := strconv.Atoi(str)
if err == nil {
fmt.Printf("result2的数据类型是%T", result2)
} else {
fmt.Println("转换失败")
}
}
//
num的数据类型是:int
str的数据类型是:string
-------
result1的数据类型是:string
--------
result2的数据类型是int
使用fmt.Sprintf(格式化字符串类型,字符串)将任意类型数据转换为字符串
格式化字符串：
- int 类型数据：%d
- string类型数据： %s
- float类型数据：%f
- bool类型数据：%t
- 指针：%p
package main
import "fmt"
func main() {
var (
num1 = 12345
num2 = 3.1415
b1 = true
)
fmt.Printf("num1是%T类型。\nnum2 是%T类型。\nb1 是%T类型\n", num1, num2, b1)
fmt.Println("--------")
result1 := fmt.Sprintf("%d", num1)
result2 := fmt.Sprintf("%f", num2)
result3 := fmt.Sprintf("%t", b1)
fmt.Printf("result1的类型是%T\n result2的类型是%T\n result3的类型是%T", result1, result2, result3)
}
//输出结果:
num1是int类型。
num2 是float64类型。
b1 是bool类型
--------
result1的类型是string
result2的类型是string
result3的类型是string
字符串格式化
| 格 式 | 描 述 |
|---|---|
| %v | 按值的本来值输出 |
| %+v | 在 %v 基础上，对结构体字段名和值进行展开 |
| %#v | 输出 Go 语言语法格式的值 |
| %t | 输出布尔值 |
| %T | 输出 Go 语言语法格式的类型和值 |
| %% | 输出 % 本体 |
| %s | 输出字符串（string和[]byte）值 |
| %b | 整型以二进制方式显示 |
| %o | 整型以八进制方式显示 |
| %d | 整型以十进制方式显示 |
| %x | 整型以十六进制方式显示 |
| %X | 整型以十六进制、字母大写方式显示 |
| %U | Unicode 字符 |
| %f | 浮点数 |
| %p | 指针，十六进制方式显示 |
| %q | 格式化字符串，在字符串的两端加上双引号 |
