go 常用标准库 时间函数

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()
}