Go语言Time包的具体使用

目录

• time包
• 时间类型（Time）
• 时间格式化
• 时间戳
• 时间间隔
• 时间操作
• 时间计算
• 时间间隔
• 之前
• 之后
• 相同
• 时间转换
• 字符串转时间
• 时间戳转时间

time包

Go语言中有关于时间和日期的方法都在time包里面，Go语言的time包为开发者提供了一套全面而简洁的工具来处理时间相关的操作。包括解析和格式化时间字符串，计算时间差和时区转换等，time包时Go语言中处理时间和日期的核心组件。

时间类型（Time）

time包中的Time结构体表示的是时间类型，在Go语言中，我们可以使用time.Now()方法来获取当前的时间，该方法返回的就是Time类型，调用Time类型的方法就可以分别获取到当前时间的年月日时分秒等信息。

func main() {
 now := time.Now()

 fmt.Println(now) // 2024-07-23 19:36:03.4481196 +0800 CST m=+0.004232101

 fmt.Println(now.Year())   // 2024
 fmt.Println(now.Month())  // July
 fmt.Println(now.Day())    // 23
 fmt.Println(now.Hour())   // 19
 fmt.Printjavascriptln(now.Minute()) // 36
 fmt.Println(now.Second()) // 3
}

时间格式化

从上面的输出可以看到当前日期的输出后面还携带了有其他的消息，不是我们常用的格式，这个时候就可以使用Go语言的时间格式化功能，使用format方法并执行格式化模板，Go语言的格式化模版并不是常用的Y-m-d H:M:S，而是2006-01-02 15:04:05，记忆方法：200612345（相传这个时间为Go语言诞生时间，不知真假）。

func main() {
 now := time.Now()
 fmt.Println(now.Format("2006-01-02 15:04:05"))    // 2024-07-23 19:37:58
 fmt.Println(now.Format("2006-01-02 03:04:05 PM")) // 2024-07-23 07:41:20 PM
 fmt.Println(now.Format("2006/01/02 15:04"))       // 2024/07/23 19:40
 fmt.Println(now.Format("15:04 2006/01/02"))       // 19:40 2024/07/23
 fmt.Println(now.Format("2006/01/02"))             // 2024/07/23
}

除了自己写格式化模版之外，Go语言已经内置了一部分模版可供选择，模版在format包里面，可以直接使用，源码如下：

const (
 Layout      = "01/02 03:04:05PM '06 -0700" // The reference time, in 编程客栈numerical order.
 ANSIC       = "Mon Jan _2 15:04:05 2006"
 UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
 rubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
 RFC822      = "02 Jan 06 15:04 MST"
 RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
 RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
 RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
 RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
 RFC3339     = "2006-01-02T15:04:05Z07:00"
 RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
 Kitchen     = "3:04PM"
 // Handy time stamps.
 Stamp      = "Jan _2 15:04:05"
 StampMilli = "Jan _2 15:04:05.000"
 StampMicro = "Jan _2 15:04:05.000000"
 StampNano  = "Jan _2 15:04:05.000000000"
 DateTime   = "2006-01-02 15:04:05"
 DateOnly   = "2006-01-02"
 TimeOnly   = "15:04:05"
)

时间戳

时间戳是自1970年1月1日（08:00:00GMT）至当前时间的总毫秒数，也被称为Unix时间戳，在Go语言里面，可以获取四种级别的时间戳，分别是秒、毫秒、微秒和纳秒。

func main() {
 now := time.Now()
 fmt.Println(now.Unix())      // 1721735188
 fmt.Println(now.UnixMilli()) // 1721735188504
 fmt.Println(now.UnixMicro()) // 1721735188504566
 fmt.Println(now.UnixNano())  // 1721735188504566800
}

时间间隔

在time包里面还定义了一个Duration类型，Duration表示时间间隔，例如可以直接使用time.Second表示1秒，time.Hour * 3表示3个小时，Duration源码定义如下：

const (
 Nanosecond  Duration = 1
 Microsecond          = 1000 * Nanosecond
 Mhttp://www.devze.comillisecond          = 1000 * Microsecond
 Second               = 1000 * Millisecond
 Minute               = 60 * Second
 Hour                 = 60 * Minute
)

时间操作

在Go语言里面还可以非常简单的进行时间的比较以及计算

时间计算

可以使用Add方法在当前时间的基础上加上指定的时间间隔。

func main() {
 now := time.Now()
 fmt.Println(now)                    // 2024-07-23 19:52:14.0840934 +0800 CST m=+0.004981601
 fmt.Println(now.Add(time.Hour * 2)) // 2024-07-23 21:52:14.0840934 +0800 CST m=+7200.004981601
}

时间间隔

还可以使用Sub方法计算两个时间之间相隔了多长时间，

func main() {
 now := time.Now()
 fmt.Println(now.Sub(now.Add(time.Hour * -2))) // 2h0m0s
}

之前

使用Before判断一个时间是否在另一个时间之前

func main() {
 now :=python time.Now()
 fmt.Println(now.Before(now.Add(time.Hour))) // true
}

之后

使用After判断一个时间是否在另一个时间之后

func main() {
 now := time.Now()
 fmt.Println(now.After(now.Add(time.Hour))) // false
}

相同

使用Equal判断两个时间是否相同

func main() {
 now := time.Now()
 fmt.Println(now.Equal(now.Add(time.Hour))) // false
}

时间转换

字符串转时间

func main() {
 timeStr := "2024-07-23 12:23:34"
 time1, _ := time.Parse(time.DateTime, timeStr)
 fmt.Println(time1) // 2024-07-23 12:23:34 +0000 UTC
 time2, _ := time.ParseInLocation(time.DateTime, timeStr, time.Local)
 fmt.Println(time2) // 2024-07-23 12:23:34 +0800 CST
}

可以使用Parse和ParseInLocation将字符串时间转成Time类型的时间，两者的区别如下：

• time.Parse 总是将时间解析为 UTC 时区
• time.ParseInLocation 允许指定一个时区解析

时间戳转时间

func main() {
 time1 := time.Unix(172173518编程客栈8, 0)
 time2 := time.UnixMilli(1721735188504)
 time3 := time.UnixMicro(1721735188504566)
 fmt.Println(time1) // 2024-07-23 19:46:28 +0800 CST
 fmt.Println(time2) // 2024-07-23 19:46:28.504 +0800 CST
 fmt.Println(time3) // 2024-07-23 19:46:28.504566 +0800 CST
}

使用time包的Unix、UnixMilli和UnixMicro可以分别将秒、毫秒、微秒级别的时间戳转成相应的Time类型的时间。

到此这篇关于Go语言Time包的文章就介绍到这了,更多相关Go语言Time包内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！