时间和日期是我们开发中经常会用到的,Go语言中的 time 包提供了时间显示和测量等所用的函数,本节我们就来介绍一下 time 包的基本用法。
时间一般包含时间值和时区,可以从Go语言中 time 包的源码中看出:
- type Time struct {
- // wall and ext encode the wall time seconds, wall time nanoseconds,
- // and optional monotonic clock reading in nanoseconds.
- //
- // From high to low bit position, wall encodes a 1-bit flag (hasMonotonic),
- // a 33-bit seconds field, and a 30-bit wall time nanoseconds field.
- // The nanoseconds field is in the range [0, 999999999].
- // If the hasMonotonic bit is 0, then the 33-bit field must be zero
- // and the full signed 64-bit wall seconds since Jan 1 year 1 is stored in ext.
- // If the hasMonotonic bit is 1, then the 33-bit field holds a 33-bit
- // unsigned wall seconds since Jan 1 year 1885, and ext holds a
- // signed 64-bit monotonic clock reading, nanoseconds since process start.
- wall uint64
- ext int64
-
- // loc specifies the Location that should be used to
- // determine the minute, hour, month, day, and year
- // that correspond to this Time.
- // The nil location means UTC.
- // All UTC times are represented with loc==nil, never loc==&utcLoc.
- loc *Location
- }
上面代码中:
公认最准确的计算应该是使用“原子震荡周期”所计算的物理时钟了(Atomic Clock, 也被称为原子钟),这也被定义为标准时间(International Atomic Time)。
而我们常常看见的 UTC(Universal Time Coordinated,世界协调时间)就是利用这种 Atomic Clock 为基准所定义出来的正确时间。UTC 标准时间是以 GMT(Greenwich Mean Time,格林尼治时间)这个时区为主,所以本地时间与 UTC 时间的时差就是本地时间与 GMT 时间的时差。
国内一般使用的是北京时间,与 UTC 的时间关系如下:
在Go语言的 time 包里面有两个时区变量,如下:
同时,Go语言还提供了 LoadLocation 方法和 FixedZone 方法来获取时区变量,如下:
其中,name 为时区名称,offset 是与 UTC 之前的时差。
其中,name 为时区的名字。
我们可以通过 time.Now() 函数来获取当前的时间对象,然后通过事件对象来获取当前的时间信息。示例代码如下:
- 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.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
- }
运行结果如下:
时间戳是自 1970 年 1 月 1 日(08:00:00GMT)至当前时间的总毫秒数,它也被称为 Unix 时间戳(UnixTimestamp)。基于时间对象获取时间戳的示例代码如下:
- package main
-
- import (
- "fmt"
- "time"
- )
-
- func main() {
- now := time.Now() //获取当前时间
- timestamp1 := now.Unix() //时间戳
- timestamp2 := now.UnixNano() //纳秒时间戳
- fmt.Printf("现在的时间戳:%v\n", timestamp1)
- fmt.Printf("现在的纳秒时间戳:%v\n", timestamp2)
- }
运行结果如下:
使用 time.Unix() 函数可以将时间戳转为时间格式,示例代码如下:
- package main
-
- import (
- "fmt"
- "time"
- )
-
- func main() {
- now := time.Now() //获取当前时间
- timestamp := now.Unix() //时间戳
- 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)
- }
运行结果如下:
time 包中的 Weekday 函数能够返回某个时间点所对应是一周中的周几,示例代码如下:
- package main
-
- import (
- "fmt"
- "time"
- )
-
- func main() {
- //时间戳
- t := time.Now()
- fmt.Println(t.Weekday().String())
- }
运行结果如下:
我们在日常的开发过程中可能会遇到要求某个时间 + 时间间隔之类的需求,Go语言中的 Add 方法如下:
Add 函数可以返回时间点 t + 时间间隔 d 的值。
【示例】求一个小时之后的时间:
- package main
-
- import (
- "fmt"
- "time"
- )
-
- func main() {
- now := time.Now()
- later := now.Add(time.Hour) // 当前时间加1小时后的时间
- fmt.Println(later)
- }
运行结果如下:
求两个时间之间的差值:
返回一个时间段 t - u 的值。如果结果超出了 Duration 可以表示的最大值或最小值,将返回最大值或最小值,要获取时间点 t - d(d 为 Duration),可以使用 t.Add(-d)。
判断两个时间是否相同:
Equal 函数会考虑时区的影响,因此不同时区标准的时间也可以正确比较,Equal 方法和用 t==u 不同,Equal 方法还会比较地点和时区信息。
判断一个时间点是否在另一个时间点之前:
如果 t 代表的时间点在 u 之前,则返回真,否则返回假。
判断一个时间点是否在另一个时间点之后:
如果 t 代表的时间点在 u 之后,则返回真,否则返回假。
使用 time.Tick(时间间隔) 可以设置定时器,定时器的本质上是一个通道(channel),示例代码如下:
- package main
-
- import (
- "fmt"
- "time"
- )
-
- func main() {
- ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器
- for i := range ticker {
- fmt.Println(i) //每秒都会执行的任务
- }
- }
运行结果如下:
时间类型有一个自带的 Format 方法进行格式化,需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S 而是使用Go语言的诞生时间 2006 年 1 月 2 号 15 点 04 分 05 秒。
提示:如果想将时间格式化为 12 小时格式,需指定 PM。
- package main
-
- import (
- "fmt"
- "time"
- )
-
- func main() {
- 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"))
- // 12小时制
- fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))
- 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"))
- }
运行结果如下:
Parse 函数可以解析一个格式化的时间字符串并返回它代表的时间。
与 Parse 函数类似的还有 ParseInLocation 函数。
ParseInLocation 与 Parse 函数类似,但有两个重要的不同之处:
示例代码如下:
- package main
-
- import (
- "fmt"
- "time"
- )
-
- func main() {
- var layout string = "2006-01-02 15:04:05"
- var timeStr string = "2019-12-12 15:22:12"
-
- timeObj1, _ := time.Parse(layout, timeStr)
- fmt.Println(timeObj1)
-
- timeObj2, _ := time.ParseInLocation(layout, timeStr, time.Local)
- fmt.Println(timeObj2)
- }
运行结果如下: