Go语言time包基础使用

本文最后更新于 2024年10月15日 下午

time包

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

时间类型（Time）

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

1
2
3
4
5
6
7
8
9
10
11
12
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.Println(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语言诞生时间，不知真假）。

1
2
3
4
5
6
7
8
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包里面，可以直接使用，源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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语言里面，可以获取四种级别的时间戳，分别是秒、毫秒、微秒和纳秒。

1
2
3
4
5
6
7
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源码定义如下：

1
2
3
4
5
6
7
8
const (
	Nanosecond  Duration = 1
	Microsecond          = 1000 * Nanosecond
	Millisecond          = 1000 * Microsecond
	Second               = 1000 * Millisecond
	Minute               = 60 * Second
	Hour                 = 60 * Minute
)

时间操作

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

时间计算

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

1
2
3
4
5
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方法计算两个时间之间相隔了多长时间，

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

之前

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

1
2
3
4
func main() {
	now := time.Now()
	fmt.Println(now.Before(now.Add(time.Hour))) // true
}

之后

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

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

相同

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

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

时间转换

字符串转时间

1
2
3
4
5
6
7
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 允许指定一个时区解析

时间戳转时间

1
2
3
4
5
6
7
8
func main() {
	time1 := time.Unix(1721735188, 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语言
#Go语言 #时间格式化
Go语言time包基础使用
http://example.com/p/ce34811b.html
作者
jrlee
发布于
2024年8月23日
许可协议