Go-time包

time包

time包提供了时间的显示和测量用的函数。日历的计算采用的是公历。

导入time包

import "time"

time包使用

func timeDemo() {
	now := time.Now() // 获取当前时间
	fmt.Printf("current time:%v\n", now)
	fmt.Println(now.Unix())     // 时间戳
	fmt.Println(now.UnixNano()) //纳秒时间戳

	year := now.Year()     // 年
	month := now.Month()   // 月
	day := now.Day()       // 日
	hour := now.Hour()     // 小时
	minute := now.Minute() // 分钟
	second := now.Second() // 秒
	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second) // 2020-010-28 15:39:11
	
	ft := "2006年01月02日 15:04:05"
    now.Format(ft)
    	//模板 占位
        //年 => 2006
        //月 => 01
        //日 => 02
        //时 => 03(12h)/15(24h)
        //分 => 04
		//秒 => 05
	fmt.Printf("%T\n", now.Format(ft)) // string
	fmt.Println(now.Format(ft)) // 2020年10月28日 15:41:25
    // 扩展
    // .000 精确到毫秒
    // PM 格式化为12小时方式，需指定PM
    // Mon 星期
    // Jan 月份
    fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan")) 
}

字符串转化成时间

func main() {
	// time.Parse: 前面时解析的格式， 后面时时间格式的字符串
	t1, err := time.Parse("2006-01-02 15:04", "2018-01-02 16:05")
	// t1, err := time.Parse("2006-01-02 15:04", "2018/01-02 16:05") 错误格式/-不一样
	fmt.Println(err, t1) //<nil> 2018-01-02 16:05:00 +0000 UTC

	t2, err := time.Parse("2006/01/02 15:04:05", "2020/10/28 15:50:20")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(t2) // 2020-10-28 15:50:20 +0000 UTC
}

时间戳转化成时间

func main() {
	timeObj := time.Unix(1603872368, 0) // 前面当前时间戳，后面0
	fmt.Println(timeObj)                // 2020-10-28 16:06:08 +0800 CST
}

Sleep：休眠

func main() {
	now := time.Now()
	fmt.Println(now) // 2020-10-28 16:41:38.741804 +0800 CST m=+0.002029601
	time.Sleep(time.Second * 2) // 传参 func(d Duration)
	now = time.Now()
	fmt.Println(now) // 2020-10-28 16:41:40.767605 +0800 CST m=+2.027830601
}

时间操作方法

time包中定义的时间间隔类型的常量如下：

const (
	Nanosecond  Duration = 1                  // 纳秒
	Microsecond          = 1000 * Nanosecond  // 微秒
	Millisecond          = 1000 * Microsecond //毫秒
	Second               = 1000 * Millisecond //秒
	Minute               = 60 * Second        //分钟
	Hour                 = 60 * Minute        //小时
)

Add

时间+时间间隔的需求，Go语言的时间对象有提供Add方法如下：

一个小时之后的时间:

func main() {
	now := time.Now()
	later := now.Add(time.Hour) // 当前时间加1小时后的时间
	fmt.Println(later)
}

Sub(有时区问题)

两个时间之间的差值

func main() {
	now := time.Now()
	fmt.Println(now)
	// 加载时区，东八区
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		fmt.Println(err)
		return
	}
	// 按照指定时区(东八区)和指定格式解析字符串时间
	timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2020/10/29 16:26:20", loc)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(timeObj)
	// 计算与当前间隔时间
	fmt.Println(timeObj.Sub(now)) // 23h59m6.1336334s
}

Equal

判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较.

func main() {
	now := time.Now()
	timeObj, err := time.Parse("2006/01/02 15:04:05", "2020/10/28 15:50:20")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(timeObj.Equal(now)) // false
	fmt.Println(now.Equal(now)) // true
}

Before

比较a时间是否b时间在之前，返回真；否则返回假。

func main() {
	now := time.Now()
	timeObj, err := time.Parse("2006/01/02 15:04:05", "2020/10/28 15:50:20")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(now.Before(timeObj)) // true

}

After

比较a时间是否在b时间之后，返回真；否则返回假。

func main() {
	now := time.Now()
	timeObj, err := time.Parse("2006/01/02 15:04:05", "2020/10/28 15:50:20")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(now.After(timeObj)) // false
}