go 常用标准库 时间函数
1.1 时间的解析和格式化
#格式TIME_FMT为 2006-01-02 15:04:05
TIME_FMT := "2006-01-02 15:04:05"
#获取当前时间 2022-05-11 13:06:16.1146258 +0800 CST m=+0.016836601
now := time.Now()
#前面定义TIME_FMT这样的时间格式，然后用now获取到当前时间，用TIME_FMT这样的格式打印出来
ts := now.Format(TIME_FMT)
#我们不建议直接fmt.Println打印时间
loc, _ = time.LoadLocation("Asia/Shanghai")
#获取时间
if t,err := time.ParseInLocation(TIME_FMT, ts, loc); err == nil {
#t.UnixMilli()是所有时间的毫秒，不是当前毫秒，粘贴出来到时间计算器可以获取当前时间
fmt.Println(t.Day(),t.Hour(),t.Minute(),t.Second(),t.UnixMilli())
} else {
fmt.Println(err)
}
2.1 时间运算
diff1 := t1.Sub(t0) //计算t1跟t0的时间差，返回类型是time.Duration
diff2 := time.Since(t0) //计算当前时间跟t0的时间差，返回类型是time.Duration
diff3 := time.Duration(3 * time.Hour) //Duration表示两个时刻之间的距离
t4 := t0.Add(diff3)
t4.After(t0) //true
时间打印及时间计算
func main() {
now := time.Now()
fmt.Println(now.Hour(),now.Minute(),now.Second())
fmt.Println(now.Day()) //获取今天是这个月的第几天
fmt.Println(now.YearDay()) //获取今天是今天的第几天
fmt.Println(now.Unix()) //秒
fmt.Println(now.UnixMilli()) //毫秒
fmt.Println(now.UnixMicro())
fmt.Printf("%d\n",now.Weekday()) //获取今天是每周的第几天
fmt.Println(now.Weekday().String()) //获取今天是星期几，并转换成string
time.Sleep(3*time.Second) //原地等待三秒钟
t2 := time.Now() //再次获取当前时间t2
//计算t2与上面时间now的间隔，因为sleep了3秒，所以这里应该是3秒
dua := t2.Sub(now)
//计算当前时间与上面时间now的记那个，这里可能和dua查了几纳秒，几乎是一样的
dua2 := time.Since(now)
fmt.Println(dua)
fmt.Println(dua2)
//这里让最开始获取的时间加上sleep的那三秒，dua就是计算的sleep那三秒
t3 := now.Add(dua)
fmt.Println(t3) //t3=t2
}
3.1 时间的属性
t0.Unix(), t0.UnixMilli(), t0.UnixMicro(), t0.UnixNano()
t2.Year(), t2.Month(), t2.Day(), t2.YearDay()
t2.Weekday().String(), t2.Weekday()
t1.Hour(), t1.Minute(), t1.Second()
4.1 定时执行
tm := time.NewTimer(3 * time.Second)
<-tm.C //阻塞3秒钟
//do something
tm.Stop()
//或者用：
<-time.After(3 * time.Second) //阻塞3秒钟
5.1 周期执行
tk := time.NewTicker(1 * time.Second)
for i := 0; i < 10; i++ {
<-tk.C //阻塞1秒钟
//do something
}
tk.Stop()
代码整理
package main
import (
"fmt"
"time"
)
var (
loc *time.Location
)
const (
TIME_FMT = "2006-01-02 15:04:05"
DATE_FMT = "20060102"
)
func init() {
loc, _ = time.LoadLocation("Asia/Shanghai")
}
func basic() {
t0 := time.Now()
fmt.Printf("秒%d, 毫秒%d, 微秒%d, 纳秒%d\n", t0.Unix(), t0.UnixMilli(), t0.UnixMicro(), t0.UnixNano())
time.Sleep(2 * time.Second) //休眠2秒钟
t1 := time.Now()
diff1 := t1.Sub(t0) //计算时间差，返回类型是time.Duration
diff2 := time.Since(t0) //等价于t1 := time.Now();t1.Sub(t0)
fmt.Printf("diff1=diff2 %t\n", int(diff1.Seconds()) == int(diff2.Seconds())) //在秒级别上diff1和diff2是相等的
fmt.Printf("t1>t0 %t\n", t1.After(t0)) //判断时间的先后顺序
d := time.Duration(3 * time.Hour) //Duration表示两个时刻之间的距离
t2 := t1.Add(d) //加一段时间
fmt.Printf("hour1 %d, hour2 %d\n", t1.Hour(), t2.Hour()) //获取一个时刻的Hour
fmt.Printf("week day %s %d\n", t2.Weekday().String(), t2.Weekday()) //周日的Weekday()是0，周六的Weekday()是6
fmt.Printf("year %d\n", t2.Year())
fmt.Printf("month %s %d %d\n", t2.Month(), t2.Month(), int(t2.Month())) //在go语言内部Month就是int类型。type Month int
fmt.Printf("day %d\n", t2.Day()) //属于一个月当中的第几天
fmt.Printf("day in year %d\n", t2.YearDay()) //属于一年当中的第几天
}
//时间格式化
func parse_format() {
now := time.Now()
ts := now.Format(TIME_FMT)
fmt.Println("格式化时间", ts)
t, _ := time.Parse(TIME_FMT, ts)
if t.Unix() != now.Unix() {
fmt.Printf("Parse时间解析错误：%d!=%d\n", t.Unix(), now.Unix())
}
t, _ = time.ParseInLocation(TIME_FMT, ts, loc)
if t.Unix() != now.Unix() {
fmt.Printf("ParseInLocation时间解析错误：%s\n", t.Format(TIME_FMT))
}
}
//周期时执行任务
func ticker() {
tk := time.NewTicker(1 * time.Second)
for i := 0; i < 10; i++ {
<-tk.C //阻塞1秒钟
fmt.Printf("现在时间是%s\n", time.Now().Format(TIME_FMT))
}
tk.Stop() //用完后记得调用Stop
}
//经过一段时间后，触发一次任务
func timer() {
fmt.Printf("现在时间是%s\n", time.Now().Format(TIME_FMT))
tm := time.NewTimer(3 * time.Second)
<-tm.C //阻塞3秒钟，最多只能连续调用一次
// <-tm.C 会死锁
fmt.Printf("现在时间是%s\n", time.Now().Format(TIME_FMT))
tm.Stop() //用完后记得调用Stop
//通过time.After也可以实现上述功能
fmt.Printf("现在时间是%s\n", time.Now().Format(TIME_FMT))
<-time.After(3 * time.Second) //阻塞3秒钟
fmt.Printf("现在时间是%s\n", time.Now().Format(TIME_FMT))
}
func main() {
basic()
fmt.Println()
parse_format()
fmt.Println()
ticker()
fmt.Println()
timer()
}
