go语言中time包的各种函数总结

宁愿是朱砂痣

前言

在我们开发的过程中，每个项目都需要时间这一类的函数，此时，对time这个包的研究深度就显得尤为重要，现在，对time包中的各种函数做出一个总结，加深一些记忆，

时间类型

Go语言中，time.Time类型表示时间。我们可以通过time.Now函数获取当前时间的对象，然后从时间对象中获取到年，月，日，时，分，秒等信息，代码如下

1. // timeDemo 时间对象的年月日时分秒
   
2. func timeDemo() {
   
3.         now := time.Now() // 获取当前时间
   
4.         fmt.Printf("current time:%v\n", now)
   
5. 
   
6.         year := now.Year()     // 年
   
7.         month := now.Month()   // 月
   
8.         day := now.Day()       // 日
   
9.         hour := now.Hour()     // 小时
   
10.         minute := now.Minute() // 分钟
    
11.         second := now.Second() // 秒
    
12.         fmt.Println(year, month, day, hour, minute, second)
    
13. }

复制代码

Location和time zone

Go 语言中使用 location 来映射具体的时区。时区（Time Zone）是根据世界各国家与地区不同的经度而划分的时间定义，全球共分为24个时区。中国差不多跨5个时区，但为了使用方便只用东八时区的标准时即北京时间为准。
下面的示例代码中使用beijing来表示东八区8小时的偏移量，其中time.FixedZone和time.LoadLocation`这两个函数则是用来获取location信息。

1. // timezoneDemo 时区示例
   
2. func timezoneDemo() {
   
3.         // 中国没有夏令时，使用一个固定的8小时的UTC时差。
   
4.         // 对于很多其他国家需要考虑夏令时。
   
5.         secondsEastOfUTC := int((8 * time.Hour).Seconds())
   
6.         // FixedZone 返回始终使用给定区域名称和偏移量(UTC 以东秒)的 Location。
   
7.         beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)
   
8. 
   
9.         // 如果当前系统有时区数据库，则可以加载一个位置得到对应的时区
   
10.         // 例如，加载纽约所在的时区
    
11.         newYork, err := time.LoadLocation("America/New_York") // UTC-05:00
    
12.         if err != nil {
    
13.                 fmt.Println("load America/New_York location failed", err)
    
14.                 return
    
15.         }
    
16.         fmt.Println()
    
17.         // 加载上海所在的时区
    
18.         //shanghai, err := time.LoadLocation("Asia/Shanghai") // UTC+08:00
    
19.         // 加载东京所在的时区
    
20.         //tokyo, err := time.LoadLocation("Asia/Tokyo") // UTC+09:00
    
21. 
    
22.         // 创建时间对象需要指定位置。常用的位置是 time.Local（当地时间） 和 time.UTC（UTC时间）。
    
23.         //timeInLocal := time.Date(2009, 1, 1, 20, 0, 0, 0, time.Local)  // 系统本地时间
    
24.         timeInUTC := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
    
25.         sameTimeInBeijing := time.Date(2009, 1, 1, 20, 0, 0, 0, beijing)
    
26.         sameTimeInNewYork := time.Date(2009, 1, 1, 7, 0, 0, 0, newYork)
    
27. 
    
28.         // 北京时间（东八区）比UTC早8小时，所以上面两个时间看似差了8小时，但表示的是同一个时间
    
29.         timesAreEqual := timeInUTC.Equal(sameTimeInBeijing)
    
30.         fmt.Println(timesAreEqual)
    
31. 
    
32.         // 纽约（西五区）比UTC晚5小时，所以上面两个时间看似差了5小时，但表示的是同一个时间
    
33.         timesAreEqual = timeInUTC.Equal(sameTimeInNewYork)
    
34.         fmt.Println(timesAreEqual)
    
35. }

复制代码

时间间隔

time.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。time.Duration表示一段时间间隔，可表示的最长时间段大约290年。

Add

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

复制代码

sub

返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值。要获取时间点t-d（d为Duration），可以使用t.Add(-d)。

1. func (t Time) Sub(u Time) Duration

复制代码

Before

如果t代表的时间点在u之前，返回真；否则返回假

1. func (t Time) Before(u Time) bool

复制代码

After

如果t代表的时间点在u之后，返回真；否则返回假。

1. func (t Time) After(u Time) bool

复制代码

定时器

使用time.Tick(时间间隔)来设置定时器，定时器的本质上是一个通道（channel）。

1. unc tickDemo() {
   
2.         ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器
   
3.         for i := range ticker {
   
4.                 fmt.Println(i)//每秒都会执行的任务
   
5.         }
   
6. }

复制代码

时间格式化

time.Format函数能够将一个时间对象格式化输出为指定布局的文本表示形式，需要注意的是 Go 语言中时间格式化的布局不是常见的Y-m-d H:M:S，而是使用 2006-01-02 15:04:05.000（记忆口诀为2006 1 2 3 4 5）。
其中：

1. 2006：年（Y）01：月（m）02：日（d）15：时（H）04：分（M）05：秒（S）`

复制代码

1. // formatDemo 时间格式化
   
2. func formatDemo() {
   
3.         now := time.Now()
   
4.         // 格式化的模板为 2006-01-02 15:04:05
   
5. 
   
6.         // 24小时制
   
7.         fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))
   
8.         // 12小时制
   
9.         fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))
   
10. 
    
11.         // 小数点后写0，因为有3个0所以格式化输出的结果也保留3位小数
    
12.         fmt.Println(now.Format("2006/01/02 15:04:05.000")) // 2022/02/27 00:10:42.960
    
13.         // 小数点后写9，会省略末尾可能出现的0
    
14.         fmt.Println(now.Format("2006/01/02 15:04:05.999")) // 2022/02/27 00:10:42.96
    
15. 
    
16.         // 只格式化时分秒部分
    
17.         fmt.Println(now.Format("15:04:05"))
    
18.         // 只格式化日期部分
    
19.         fmt.Println(now.Format("2006.01.02"))
    
20. }

复制代码

时间格式化的时间

对于从文本的时间表示中解析出时间对象，time包中提供了time.Parse和time.ParseInLocation两个函数。
其中time.Parse在解析时不需要额外指定时区信息。

1. // parseDemo 指定时区解析时间
   
2. func parseDemo() {
   
3.         // 在没有时区指示符的情况下，time.Parse 返回UTC时间
   
4.         timeObj, err := time.Parse("2006/01/02 15:04:05", "2022/10/05 11:25:20")
   
5.         if err != nil {
   
6.                 fmt.Println(err)
   
7.                 return
   
8.         }
   
9.         fmt.Println(timeObj) // 2022-10-05 11:25:20 +0000 UTC
   
10. 
    
11.         // 在有时区指示符的情况下，time.Parse 返回对应时区的时间表示
    
12.         // RFC3339     = "2006-01-02T15:04:05Z07:00"
    
13.         timeObj, err = time.Parse(time.RFC3339, "2022-10-05T11:25:20+08:00")
    
14.         if err != nil {
    
15.                 fmt.Println(err)
    
16.                 return
    
17.         }
    
18.         fmt.Println(timeObj) // 2022-10-05 11:25:20 +0800 CST

复制代码

总结

到此这篇关于go语言中time包的各种函数总结的文章就介绍到这了,更多相关go语言time包内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

海子梦巧

路过，支持一下

一如既往325

感谢楼主分享。

ln181

顶顶更健康！！！