CnSwift - 雨燕

agile development - 敏捷开发

Golang语言之字符串操作

Golang语言之字符串操作与时间类型转换字符串类型

go version go1.14

转义字符

verb 含义
%d 十进制整数
%x,%X 大小写方式显式十六进制整数
%o 八进制整数
%b 二进制整数
%f,%g,%e 浮点数
%t 布尔值
%c 字符
%s 字符串
%q 带双引号的字符串
%v 内置格式内容
%T 类型
%p 内存地址
%% 字符%
\n 换行
\t 缩进

字符串与数值相互转换

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
40
41
package main

import (
"fmt"
"strconv"
)

func main() {
// 字符串转数值
var str string = "100"
/**
* param:string
* return:int,error
*/
num, _ := strconv.Atoi(str)
fmt.Printf("%T\n", num)

/*
* param str,进制,类型
* return int64,err
*/
num1, _ := strconv.ParseInt(str, 0, 64)
fmt.Printf("%T\n", num1)

// 数值转字符串
var number int = 200
/*
* param int
* return string
*/
str1 := strconv.Itoa(number)
fmt.Printf("%T\n", str1)

var number2 int64 = 500
/*
* param int64, 进制
* return string
*/
str2 := strconv.FormatInt(number2, 10)
fmt.Printf("%T\n", str2)
}

字符串操作

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package main

import (
"fmt"
"strings"
)

func main() {
var str string = "frank弗兰克"
fmt.Println(len(str))
// 字符串截取
str1 := str[0]
fmt.Println(str1)
fmt.Printf("%T\n", str1)
str2 := fmt.Sprintf("%c", str1)
// 取字符
fmt.Printf("%T\n", str2)
fmt.Println(str2)

// 范围截取
str3 := str[0:2]
fmt.Printf("%T\n", str3)
fmt.Println(str3)
str4 := str[:3]
fmt.Printf("%T\n", str4)
fmt.Println(str4)
str5 := str[5:]
fmt.Printf("%T\n", str5)
fmt.Println(str5)

// 字符串转切片
s1 := []rune(str)
fmt.Printf("%T\n", s1)
fmt.Println(len(s1))
fmt.Println(s1[0])
// 取字符
fmt.Printf("%c\n", s1[0])
fmt.Printf("%c\n", s1[5])

// 遍历字符串
for i, n := range str {
// fmt.Println(i, n)
// 打印字符
fmt.Printf("%d=>%c\n", i, n)
}

// 常用字符串函数
// HasPrefix 前缀
// isOk := strings.HasPrefix(str, "fr")
// HasSuffix 后缀
// isOk := strings.HasSuffix(str, "博")
// Contains 包含子串
// isOk := strings.Contains(str, "an")
// fmt.Printf("%t\n", isOk)
// Index 子串第一次出现的位置
// index := strings.Index(str, "r")
// LastIndex 子串最后出现的位置
index := strings.LastIndex(str, "a")
fmt.Printf("%d\n", index)
// ToLower 转小写
strL := strings.ToLower(str)
fmt.Printf("%s\n", strL)
// ToUpper 转大写
strU := strings.ToUpper(str)
fmt.Printf("%s\n", strU)
// Replace 替换
strNew := strings.Replace(str, "a", "b", 1)
fmt.Printf("%s\n", strNew)
// Trim 去除字符串前后的指定字符
strNew2 := strings.Trim(str, "f")
fmt.Printf("%s\n", strNew2)
// Split 字符串切分成切片
slice := strings.Split(str, "")
fmt.Println(slice)
// Join 切片组合成字符串
strSlice := strings.Join(slice, "+")
fmt.Printf("%s\n", strSlice)

}

时间类型&时间类型与字符串类型互相转换

package main

import (
"fmt"
"time"
)

func main() {
// time 包
// 声明 Time 类型
var t time.Time
fmt.Println(t)
// time.Now()函数,获取当前时间
t1 := time.Now()
fmt.Printf("%T\n", t1)
fmt.Println(t1)

/*
 * 通过纳秒时间戳创建时间变量
 * param: 秒,纳秒
 * return:time.Time
 */
t2 := time.Unix(0, t1.UnixNano())
fmt.Println(t2)

// 根据自己要求创建时间
t3 := time.Date(2020, 6, 10, 16, 51, 03, 123, time.Local)
fmt.Println(t3)
// 其它函数
year := t3.Year()
month := t3.Month()
monthInt := int(month)
day := t3.Day()
hour := t3.Hour()
minute := t3.Minute()
second := t3.Second()
nanosec := t3.Nanosecond()
fmt.Println(year)
fmt.Println(month)
fmt.Println(monthInt)
fmt.Println(day)
fmt.Println(hour)
fmt.Println(minute)
fmt.Println(second)
fmt.Println(nanosec)
y, m, d := t3.Date()
fmt.Println(y, m, d)
fmt.Println(t3.Clock())
// 时间类型转换字符串
timeStr := t1.Format("2006-01-02 15:04:05")
fmt.Printf("%T\n", timeStr)
fmt.Printf("%s\n", timeStr)
// 字符串类型转换成时间类型
str := "1990-11-16 07:30:08"
t4, _ := time.Parse("2006-01-02 15:04:05", str)
fmt.Printf("%T\n", t4)
fmt.Println(t4)
}
更多精彩内容,请关注公众号 Golang语言开发栈公众号二维码
感谢赞赏.

Welcome to my other publishing channels