strings
package main
import (
"fmt"
"strings"
)
func main() {
/* strings 字符串常用包 */
s1 := "goStudyGoDay"
//s1[0] = "a" // 1.字符串不能通过下标修改数据
// 2. strings.Contains 判断 某个字符是否包含了指定内容 . and 判断
fmt.Println(strings.Contains(s1, "go")) // true
fmt.Println(strings.Contains(s1, "gos")) // false
// 3. strings.ContainsAny 判断 某个字符串是否包含多个字符中的某一个. or 判断
fmt.Println(strings.ContainsAny(s1, "gos")) // true
fmt.Println(strings.ContainsAny(s1, "go")) // true
// 4. strings.Count 统计某个字符串出现的次数
fmt.Println(strings.Count(s1, "o")) // 2
fmt.Println(strings.Count(s1, "Go")) // 1
// 5. strings.HasPrefix 以什么字符串开头
s2 := "性感三上悠亚上悠亚.mp4"
fmt.Println(strings.HasPrefix(s2, "性")) // true
fmt.Println(strings.HasPrefix(s2, "女性")) // false
// 5. strings.HasSuffix 以什么字符串结尾
fmt.Println(strings.HasSuffix(s2, ".mp3")) // false
fmt.Println(strings.HasSuffix(s2, ".mp4")) // true
// 6. string.Index 找到第一次 【`字符`】 位置返回下标。找不到返回 -1
fmt.Println(strings.Index(s2, "上亚")) // -1
fmt.Println(strings.Index(s2, "上")) // 9 ，一个中文3个字符
// 7. string.LastIndex 找到最后一次 【`字符`】 位置返回下标。找不到返回 -1
fmt.Println(strings.LastIndex(s2, "上亚")) // -1
fmt.Println(strings.LastIndex(s2, "上")) // 18 ，一个中文3个字符
// 8. strings.Join 拼接字符串
strArr := []string{"a", "b", "c", "d", "e", "f"}
fmt.Println(strings.Join(strArr, "----"))
// 9. strings.Split 拆分字符串
s3 := "a----b----c----d----e----f"
fmt.Println(strings.Split(s3, "-")) // [a b c d e f]
fmt.Println(strings.Split(s3, "--")) // [a b c d e f]
fmt.Println(strings.Split(s3, "---")) // [a -b -c -d -e -f]
fmt.Println(strings.Split(s3, "----")) // [a b c d e f]
// 10. 大小写:strings.ToLower , strings.ToUpper
sUpper := "A"
sLower := "a"
fmt.Println(strings.ToLower(sUpper))
fmt.Println(strings.ToUpper(sLower))
// 11. strings.Replace 替换 。最后一位控制替换数量，-1表示替换所有
// 11.1. ReplaceAll 替换全部
sReplace := "aaabbbccc"
fmt.Println(strings.Replace(sReplace, "a", "A", 1)) // Aaabbbccc
fmt.Println(strings.Replace(sReplace, "a", "A", -1)) // AAAbbbccc
fmt.Println(strings.ReplaceAll(sReplace, "a", "A")) // AAAbbbccc
// 12. 截取字符串
str5 := sReplace[:3]
fmt.Println("截取字符串：", str5) // 截取字符串： aaa
}
strconv
package main
import (
"fmt"
"strconv"
)
func main() {
/* 字符串转换包 strconv */
// 字符串 转换成 布尔值 strconv.ParseBool
strToBool := "true"
strToBoolRes, err := strconv.ParseBool(strToBool)
fmt.Printf("[strconv.ParseBool 字符串 转换成 布尔值] 类型：%T,%v\n", strToBoolRes, strToBoolRes)
if err != nil {
fmt.Println("err:", err)
return
}
// 布尔值 转换成 字符串 strconv.FormatBool(
boolToStr := true
strToStrRes := strconv.FormatBool(boolToStr)
fmt.Printf("[strconv.FormatBool 布尔值 转换成 字符串 ] 类型：%T,%v\n", strToStrRes, strToStrRes)
// 字符串 转换成 整型 strconv.Atoi # 仅限10进制
strToInt := "123"
strToIntRes, err := strconv.Atoi(strToInt)
if err != nil {
fmt.Println("err:", err)
return
}
fmt.Printf("[strconv.Atoi 字符串 转换成 整型] 类型：%T,%v\n", strToIntRes, strToIntRes)
// 整型 转 字符串 strconv.Itoa # 仅限10进制
intToStr := 10
intToStrRes := strconv.Itoa(intToStr)
fmt.Printf("[strconv.Itoa 整型 转换成 字符串] 类型：%T,%v\n", intToStrRes, intToStrRes)
// 字符串 转换成 整型 strconv.ParseInt(字符串，进制，大小)
strToInt2 := "100"
strToIntRes2, err := strconv.ParseInt(strToInt2, 10, 64)
fmt.Printf("[strconv.ParseInt 字符串 转换成 base 10进制 的64位整型] 类型：%T,%v\n", strToIntRes2, strToIntRes2) // 100 的 十进制 为： 100
strToIntRes3, err := strconv.ParseInt(strToInt2, 2, 64)
fmt.Printf("[strconv.ParseInt 字符串 转换成 base 2进制 的64位整型] 类型：%T,%v\n", strToIntRes3, strToIntRes3) // 100 的 二进制 为： 4
if err != nil {
fmt.Println("err:", err)
return
}
// 整型 转 字符串 strconv.FormatInt : int64
intToStr2 := int64(1000)
intToStrRes2 := strconv.FormatInt(intToStr2, 2)
fmt.Printf("[strconv.FormatInt 整型 转换成 2进制的字符串] 类型：%T,%v\n", intToStrRes2, intToStrRes2) // string,1111101000
intToStrRes3 := strconv.FormatInt(intToStr2, 8)
fmt.Printf("[strconv.FormatInt 整型 转换成 8进制的字符串] 类型：%T,%v\n", intToStrRes3, intToStrRes3) // string,1750
intToStrRes4 := strconv.FormatInt(intToStr2, 10)
fmt.Printf("[strconv.FormatInt 整型 转换成 10进制的字符串] 类型：%T,%v\n", intToStrRes4, intToStrRes4) // string,1000
// 字符串 转换成 浮点数 strconv.ParseFloat
strToFloat := "123.123"
strToFloatRes, err := strconv.ParseFloat(strToFloat, 64)
if err != nil {
fmt.Println("err:", err)
return
}
fmt.Printf("[strconv.ParseFloat 字符串 转换成 浮点数] 类型：%T,%v\n", strToFloatRes, strToFloatRes)
// 浮点数 转 字符串
floatToStr := 3.141592653589793
floatToStrRes1 := strconv.FormatFloat(floatToStr, 'f', -1, 64)
fmt.Printf("[strconv.FormatFloat 浮点数 转换成 字符串 . f 格式化 -1 。保持精度] 类型：%T,%v\n", floatToStrRes1, floatToStrRes1) // string,3.141592653589793
floatToStrRes2 := strconv.FormatFloat(floatToStr, 'F', -1, 64)
fmt.Printf("[strconv.FormatFloat 浮点数 转换成 字符串 . F 格式化] 类型：%T,%v\n", floatToStrRes2, floatToStrRes2) // string,%F
floatToStrRes3 := strconv.FormatFloat(floatToStr, 'f', 2, 64)
fmt.Printf("[strconv.FormatFloat 浮点数 转换成 字符串 . f 格式化，保留小数点后两位 ] 类型：%T,%v\n", floatToStrRes3, floatToStrRes3) // string,3.14
floatToStrRes4 := strconv.FormatFloat(floatToStr, 'e', -1, 64)
fmt.Printf("[strconv.FormatFloat 浮点数 转换成 字符串 . e 格式化：科学技术法 ] 类型：%T,%v\n", floatToStrRes4, floatToStrRes4) // string,3.141592653589793e+00
}
time 时间
- 固定的格式化模板：2006年1月2号下午3点4分 格式化代码： 2006-01-02 15:04:05
package main
import (
"fmt"
"strconv"
"time"
)
func getNowTime() time.Time {
return time.Now()
}
func main() {
/* time 时间包 */
// 1. 获取当前时间
nowTime := getNowTime()
fmt.Println("当前时间:", nowTime) // 2024-06-02 03:08:54.813617 +0800 CST m=+0.000534084 : utc+8
fmt.Printf("当前时间类型：%T", nowTime) // time.Time 结构体
// fmt.Printf 的 ： %02d ， 02表示补位
fmt.Printf("年月日：%d-%02d-%02d\n", nowTime.Year(), nowTime.Month(), nowTime.Day())
fmt.Printf("时分秒：%d:%02d:%02d\n", nowTime.Hour(), nowTime.Minute(), nowTime.Second())
// 2. 时间结构化，即将时间结构体转换成字符串，能读懂的字符串格式。 而且必须使用固定模板 【好TM奇葩的方式】
// - 固定的格式化模板：2006年1月2号下午3点4分 格式化代码： 2006-01-02 15:04:05
fmt.Println(nowTime.Format("2006-01-02 15:04:05")) // 2024-06-02 03:21:14 。 24小时制
fmt.Println(nowTime.Format("2006/01/02 15:04:05")) // 2024-06-02 03:21:14 。 24小时制
fmt.Println(nowTime.Format("2006-01-02 15:04:05 PM")) // 2024-06-02 03:21:14 。 12小时制
fmt.Println(nowTime.Format("2006-01-02 15:04:05 AM")) // 2024-06-02 03:21:14 。 12小时制
// - 固定的格式化模板：2006年1月2号下午3点4分 格式化代码： 2006-01-02 03:04:05
fmt.Println(nowTime.Format("2006-01-02 03:04:05")) // 2024-06-02 03:21:14 。 24小时制
fmt.Println(nowTime.Format("2006/01/02 03:04:05")) // 2024-06-02 03:21:14 。 24小时制
fmt.Println(nowTime.Format("2006-01-02 03:04:05 PM")) // 2024-06-02 03:21:14 。 12小时制
fmt.Println(nowTime.Format("2006-01-02 03:04:05 AM")) // 2024-06-02 03:21:14 。 12小时制
// 3. 字符串时间格式化成时间结构体
strTime := "2024-06-02 03:26:13"
// 获取当前时区 :
fmt.Println("当前时间的时区:", nowTime.Location()) // Local
fmt.Printf("当前时间的时区: %T\n", nowTime.Location()) // 类型： *time.Location:
nowTimeZone, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
fmt.Println(err)
}
fmt.Println("当前时间的时区：", nowTimeZone)
//time.Parse(strTime,"2024-06-02 03:26:13")
// layout 必须使用时间模板 。 日了 像TM煞笔的操作。 //2006-01-02 03:04:05
strToTime, _ := time.ParseInLocation("2006-01-02 03:04:05", strTime, nowTimeZone)
fmt.Println(strToTime) // 0001-01-01 00:00:00 +0000 UTC
// 3. 时间戳 unix
// 当前时间的时间戳
fmt.Println("当前时间的时间戳 毫秒:", nowTime.Unix()) // 1717270954
fmt.Println("当前时间的时间戳 微秒:", nowTime.UnixMicro()) // 1717271015417561
fmt.Println("当前时间的时间戳 纳秒:", nowTime.UnixNano()) // 1717271015417561000
// unix 时间戳 转换为 时间结构体
unixToTime := time.Unix(1717270954, 0)
fmt.Println(unixToTime)
// 4. 获取当前时间。通过Unix方法获取当前时间的时间戳数据， 也可以跟根据时间戳（int64/str）转换为 *time.Time时间结构体
strTimeStamp := "1717270954"
strTimeStampRes, _ := strconv.ParseInt(strTimeStamp, 10, 64)
fmt.Println("字符串转为时间结构体:", time.Unix(strTimeStampRes, 0))
int64TimeStamp := 1717270954
fmt.Println("浮点型转为时间结构体:", time.Unix(int64(int64TimeStamp), 0))
// 5. 时间的相加，相减
fmt.Println("DDD 当前时间:", nowTime)
addNowTime := nowTime.Add(time.Hour)
fmt.Println("时间加1个小时", addNowTime)
subNowTime := nowTime.Sub(nowTime.Add(time.Hour * -1))
fmt.Printf("subNowTime 的类型：%T\n", subNowTime) // time.Duration
fmt.Printf("subNowTime.Hours() 的类型：%T\n", subNowTime.Hours()) // float64
fmt.Printf("subNowTime.Minutes() 的类型：%T\n", subNowTime.Minutes()) // float64
fmt.Println("时间减去1个小时", subNowTime)
fmt.Println("时间减去1个小时", subNowTime.Hours())
// 6. 时间的比较
afterTime := addNowTime
fmt.Println(afterTime.Equal(nowTime)) // false A 时间 和 B 时间 比较。
fmt.Println(nowTime.Equal(nowTime)) // false A 时间 和 B 时间 比较。 相等为：true 不想等为false
fmt.Println(afterTime.Before(nowTime)) // false A 时间在 B 时间 之后
fmt.Println(afterTime.After(nowTime)) // true A 时间在 B 时间 之前
}
time 的定时器 Duration
package main
import (
"fmt"
"time"
)
func main() {
/* Duration 是 一个类型 */
// - time.Duration 是 time 包定义的一个类型。 表示两个时间点进过的时间
// - 以纳秒为单位。 最长时段290年
// - time包中定义的时间间隔类型如下：
/*
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)
*/
// 使用 Tick [通道] 编写一个定时器
tickObj := time.Tick(time.Second) // 每一秒都会触发
for t := range tickObj {
fmt.Println("tickObj:", t) // tickObj: 2024-06-02 04:17:42.216701 +0800 CST m=+1.001166834
}
}
rand 随机
package main
import (
"fmt"
"math/rand"
)
func main() {
/* math 数学模块的rand 已经移除的 seed随机种子 */
randomNum1 := rand.Int()
fmt.Println("randomNum1:", randomNum1) // 7366521820015135345
randomNum2 := rand.Int()
fmt.Println("randomNum2:", randomNum2) // 4128579512189369501
randomNum3 := rand.Intn(10)
fmt.Println("randomNum3:", randomNum3) // 0
randomNum4 := rand.Intn(10)
fmt.Println("randomNum4:", randomNum4) // 6
// 随机数 需要一个 随机种子
// 设置随机数种子
//nowTimeUnix := time.Now().Unix()
//rand.Seed(nowTimeUnix) // 方法即将被移除 。 哈哈 学习的资料不正确啦
for i := 0; i < 5; i++ {
randomNum3 := rand.Intn(100)
fmt.Println("randomNum3 ", i, ":", randomNum3) // 6694779374027255800
}
}
