目录
time库
-
time库是Go语言内置的库，用来定义和操作时间、日期
-
time.Sleep(time.Second * 3) // 睡眠3秒，同python的time.sleep()方法
1. 时间类型
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now() // 获取当前时间
fmt.Printf("current time:%v\n", now)
year := now.Year() // 获取时间类型的年
month := now.Month() // 获取时间类型的月
day := now.Day() // 获取时间类型的日
hour := now.Hour() // 获取时间类型的小时
minute := now.Minute() // 获取时间类型的分钟
second := now.Second() // 获取时间类型的秒
fmt.Println(year, month, day, hour, minute, second)
fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}
/*
current time:2024-02-28 10:46:22.6884166 +0800 CST m=+0.005582101
2024 February 28 10 46 22
2024-02-28 10:46:22
*/
2. 时间戳
- 时间戳是自1970年1月1日（08:00:00GMT）至当前时间的总毫秒数。它也被称为Unix时间戳
（1）时间格式转化为时间戳
Unix() 和 UnixNano()
package main
import (
"fmt"
"time"
)
func timestampDemo() {
now := time.Now() // 获取当前时间
timestamp1 := now.Unix() // 将当前时间转化为时间戳*****************
timestamp2 := now.UnixNano() // 将当前时间转化为纳秒时间戳
fmt.Printf("current timestamp1:%v\n", timestamp1)
fmt.Printf("current timestamp2:%v\n", timestamp2)
}
// current timestamp1:1709088606
// current timestamp2:1709088606669159200
（2）时间戳转换为时间格式
time.Unix()
package main
import (
"fmt"
"time"
)
func timestampDemo2(timestamp int64) {
timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式
fmt.Println(timeObj)
year := timeObj.Year() //年
month := timeObj.Month() //月
day := timeObj.Day() //日
hour := timeObj.Hour() //小时
minute := timeObj.Minute() //分钟
second := timeObj.Second() //秒
fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}
func main() {
now := time.Now() //获取当前时间
timestamp1 := now.Unix() //时间戳
timestampDemo2(timestamp1)
}
// 2024-02-28 10:56:36 +0800 CST
// 2024-02-28 10:56:36
3. 时间间隔类型
Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。Duration表示一段时间间隔，可表示的最长时间段大约290年
time包中定义的时间间隔类型的常量如下：
1. 该类型的值的单位有如下几种：
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)
2. 定义一个Duration类型变量
var jiange time.Duration
jiange = time.Second // 赋值 1秒时间间隔 给 jiange
jiange = time.Hour // 赋值 1小时时间间隔 给 jiange
4. 时间的操作
（1）时间格式化
- 时间类型有一个自带的方法
Format进行格式化，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S而是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为2006 1 2 3 4） - 补充：如果想格式化为12小时方式，需指定
PM，Mon Jan分别表示当时的星期和月份
package main
import (
"fmt"
"time"
)
func formatDemo() {
now := time.Now()
// 格式化的模板为Go的出生时间2006年1月2号15点04分 Mon Jan
// 24小时制
fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan")) // 000为精确到小数点后3位
// 12小时制
fmt.Println(now.Format("2006-01-02 03:04:05.00 PM Mon Jan")) // 000为精确到小数点后2位
fmt.Println(now.Format("2006/01/02 15:04"))
fmt.Println(now.Format("15:04 2006/01/02"))
fmt.Println(now.Format("2006/01/02"))
}
func main() {
formatDemo()
}
/*
2024-02-28 11:27:20.148 Wed Feb
2024-02-28 11:27:20.14 AM Wed Feb
2024/02/28 11:27
11:27 2024/02/28
2024/02/28
*/
（2）解析字符串类型的时间
package main
import (
"fmt"
"time"
)
func time_string() {
now := time.Now()
fmt.Println("000 now:", now)
// 加载时区
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
fmt.Println(err)
return
}
fmt.Println("111 loc:", loc)
// 按照指定时区 和 指定格式 解析 字符串时间2024/02/28 11:46:20
my_time, err := time.ParseInLocation("2006/01/02 15:04:05", "2024/02/28 11:46:20", loc)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("222 my_time:", my_time)
fmt.Println("333 my_time.Sub(now):", my_time.Sub(now)) // my_time.Sub(now) 相当于 my_time - now 的差值
}
func main() {
time_string()
}
/*
000 now: 2024-02-28 11:46:57.6179639 +0800 CST m=+0.004948901
111 loc: Asia/Shanghai
222 my_time: 2024-02-28 11:46:20 +0800 CST
333 my_time.Sub(now): -37.6179639s
*/
（3）时间加时间间隔
Add方法定义（不是函数）： func (t Time) Add(d Duration) Time
示例：
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println(now)
later := now.Add(time.Hour) // 当前时间加1小时后的时间
fmt.Println(later)
later = now.Add(time.Minute * 2) // 当前时间加2分钟后的时间
fmt.Println(later)
}
（4）两个时间之差
Sub方法定义（不是函数）： func (t Time) Sub(u Time) Duration
返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值。要获取时间点t-d（d为Duration），可以使用t.Add(-d)
示例：见上面时间格式化中示例的 Sub
（5）时间是否相同
Equal方法定义（不是函数）： func (t Time) Equal(u Time) bool
判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。本方法和用t==u不同，这种方法还会比较地点和时区信息
（6）判断时间前后
Before 和 After
Before方法定义（不是函数）： func (t Time) Before(u Time) bool
如果t代表的时间点在u之前，返回真；否则返回假
After方法定义（不是函数）： func (t Time) After(u Time) bool
如果t代表的时间点在u之后，返回真；否则返回假
（7）定时器
- 使用
time.Tick(时间间隔)来设置定时器，定时器的本质上是一个通道（channel）
示例：
func tickDemo() {
ticker := time.Tick(time.Second * 2) // 定义一个2秒间隔的定时器
for i := range ticker {
fmt.Println(i) // 每2秒都会执行的任务
}
}
// 该for循环不会停止，类似计划任务