go time 包以及日期函

time包

时间和日期是我们编程中经常会用到的，在 golang 中 time 包提供了时间的显示和测量用的函数。

time.Now()获取当前时间

我们可以通过 time.Now()函数获取当前的时间对象，然后获取时间对象的年月日时分秒等信息。

代码示例：

go 复制代码

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)
}

运行结果：

text 复制代码

current time:2025-02-06 11:04:49.7122626 +0800 CST m=+0.000530201
2025-02-06 11:04:49

注意：%02d 中的 2 表示宽度，如果整数不够 2 列就补上0

Format 方法格式化输出日期字符串

代码示例：

go 复制代码

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"))
	// 12 小时制
	fmt.Println(now.Format("2006-01-02 03:04:05"))
	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"))
}

运行结果：

text 复制代码

2025-02-06 11:07:23
2025-02-06 11:07:23
2025/02/06 11:07
11:07 2025/02/06
2025/02/06

获取当前的时间戳

时间戳是自 1970 年 1 月 1 日（08:00:00GMT）至当前时间的总毫秒数。它也被称为 Unix 时间戳（UnixTimestamp）。

基于时间对象获取时间戳的示例代码如下：

go 复制代码

package main

import (
	"fmt"
	"time"
)

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

运行结果：

text 复制代码

current timestamp1:1738811398
current timestamp2:1738811398754863700

时间戳转换为日期字符串（年-月-日时:分:秒）

使用 time.Unix()函数可以将时间戳转为时间格式。

代码示例：

go 复制代码

package main

import (
	"fmt"
	"time"
)

func unixToTime(timestamp int64) {
	timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式
	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)
}
func main() {
	unixToTime(1738811398)
}

运行结果：

text 复制代码

2025-02-06 11:09:58

now.Format 把时间戳格式化成日期

示例代码：

go 复制代码

package main

import (
	"fmt"
	"time"
)

func main() {
	var timestamp int64 = 1738811398             //时间戳
	t := time.Unix(timestamp, 0)                 //日期对象
	fmt.Println(t.Format("2006-01-02 03:04:05")) //日期格式化输出
}

运行结果：

text 复制代码

2025-02-06 11:09:58

日期字符串转换成时间戳

示例代码：

go 复制代码

package main

import (
	"fmt"
	"time"
)

func main() {
	t1 := "2025-02-06 11:30:30"           // 间字符串
	timeTemplate := "2006-01-02 15:04:05" //常规类型
	stamp, _ := time.ParseInLocation(timeTemplate, t1, time.Local)
	fmt.Println(stamp.Unix())
}

运行结果：

text 复制代码

1738812630

时间间隔

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

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

go 复制代码

package main

import (
	"fmt"
	"time"
)

const (
	Nanosecond  time.Duration = 1
	Microsecond               = 1000 * Nanosecond
	Millisecond               = 1000 * Microsecond
	Second                    = 1000 * Millisecond
	Minute                    = 60 * Second
	Hour                      = 60 * Minute
)

func main() {
	fmt.Println(Hour)
}

例如：time.Duration 表示 1 纳秒，time.Second 表示 1 秒。

时间操作函数

我们在日常的编码过程中可能会遇到要求时间+时间间隔的需求，Go 语言的时间对象有提供Add 方法如下：

go 复制代码

func (t Time) Add(d Duration) Time

举个例子，求一个小时之后的时间：

go 复制代码

package main

import (
	"fmt"
	"time"
)

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

运行结果：

text 复制代码

2025-02-06 11:21:10.091543 +0800 CST m=+0.000000001
2025-02-06 12:21:10.091543 +0800 CST m=+3600.000000001

求两个时间之间的差值：

go 复制代码

func (t Time) Sub(u Time) Duration

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

代码示例：

go 复制代码

package main

import (
	"fmt"
	"time"
)

func main() {
	// 定义两个时间点
	startTime := time.Date(2025, 2, 6, 10, 0, 0, 0, time.Local) // 第一个时间点
	endTime := time.Date(2025, 2, 6, 12, 30, 0, 0, time.Local)  // 第二个时间点

	// 使用 Sub 方法计算两个时间点之间的差异
	duration := endTime.Sub(startTime)

	// 打印时间差
	fmt.Printf("两个时间点之间的差异是 %v\n", duration)
	fmt.Printf("换句话说，这等于 %d 小时 %d 分钟\n", int(duration.Hours()), int(duration.Minutes())%60)
}

运行结果：

text 复制代码

两个时间点之间的差异是 2h30m0s
换句话说，这等于 2 小时 30 分钟

Equal

go 复制代码

func (t Time) Equal(u Time)

判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。本方法和用 t==u 不同，这种方法还会比较地点和时区信息。

代码示例：

go 复制代码

package main

import (
	"fmt"
	"time"
)

func main() {
	// 定义两个时间点，注意它们位于不同的时区
	time1 := time.Date(2025, 2, 6, 14, 30, 0, 0, time.FixedZone("CST", 8*60*60)) // UTC+8
	time2 := time.Date(2025, 2, 6, 6, 30, 0, 0, time.UTC)                        // UTC

	// 使用 Equal 方法比较这两个时间点
	isEqual := time1.Equal(time2)

	fmt.Printf("time1: %s\n", time1)
	fmt.Printf("time2: %s\n", time2)
	if isEqual {
		fmt.Println("time1 和 time2 表示同一时刻")
	} else {
		fmt.Println("time1 和 time2 不表示同一时刻")
	}

	// 比较相同时间点但不同时区
	time3 := time.Date(2025, 2, 6, 14, 30, 0, 0, time.FixedZone("JST", 9*60*60)) // UTC+9
	fmt.Printf("\ntime3: %s\n", time3)
	if time1.Equal(time3) {
		fmt.Println("time1 和 time3 表示同一时刻")
	} else {
		fmt.Println("time1 和 time3 不表示同一时刻")
	}
}

Before

go 复制代码

func (t Time) Before(u Time) bool

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

After

go 复制代码

func (t Time) After(u Time) bool

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

示例代码：

go 复制代码

package main

import (
	"fmt"
	"time"
)

func main() {
	// 定义三个不同的时间点
	time1 := time.Date(2025, 2, 6, 10, 0, 0, 0, time.Local)
	time2 := time.Date(2025, 2, 6, 12, 30, 0, 0, time.Local)
	time3 := time.Date(2025, 2, 6, 14, 0, 0, 0, time.Local)

	// 使用 Before 方法比较时间
	fmt.Printf("time1: %s\n", time1)
	fmt.Printf("time2: %s\n", time2)
	if time1.Before(time2) {
		fmt.Println("time1 在 time2 之前")
	} else {
		fmt.Println("time1 不在 time2 之前")
	}

	// 使用 After 方法比较时间
	fmt.Printf("\ntime2: %s\n", time2)
	fmt.Printf("time3: %s\n", time3)
	if time3.After(time2) {
		fmt.Println("time3 在 time2 之后")
	} else {
		fmt.Println("time3 不在 time2 之后")
	}

	// 比较相同的时间点
	fmt.Printf("\n再次比较 time2 和自身:\n")
	if !time2.Before(time2) && !time2.After(time2) {
		fmt.Println("time2 和它自己是同一时刻")
	}
}

运行结果：

text 复制代码

time1: 2025-02-06 10:00:00 +0800 CST
time2: 2025-02-06 12:30:00 +0800 CST
time1 在 time2 之前

time2: 2025-02-06 12:30:00 +0800 CST
time3: 2025-02-06 14:00:00 +0800 CST
time3 在 time2 之后

再次比较 time2 和自身:
time2 和它自己是同一时刻

定时器

使用 time.NewTicker(时间间隔)来设置定时器

代码示例：

go 复制代码

package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(time.Second) //定义一个 1 秒间隔的定时器
	n := 0
	for i := range ticker.C {
		fmt.Println(i) //每秒都会执行的任务
		n++
		if n > 5 {
			ticker.Stop()
			return
		}
	}
}

运行结果：

text 复制代码

2025-02-06 13:14:14.884043 +0800 CST m=+1.000000001
2025-02-06 13:14:15.8840309 +0800 CST m=+2.000000001
2025-02-06 13:14:16.8840188 +0800 CST m=+3.000000001
2025-02-06 13:14:17.8840067 +0800 CST m=+4.000000001
2025-02-06 13:14:18.8839946 +0800 CST m=+5.000000001
2025-02-06 13:14:19.8839825 +0800 CST m=+6.000000001

time.Sleep(time.Second) 来实现定时器

go 复制代码

package main

import (
	"fmt"
	"time"
)

func main() {
	for {
		time.Sleep(time.Second)
		fmt.Println("我在定时执行任务")
	}
}

参考文献

https://gobyexample.com/

https://www.w3schools.com/go/

https://go.dev/doc/tutorial/

https://www.geeksforgeeks.org/golang-tutorial-learn-go-programming-language/

go time 包以及日期函

time包

time.Now()获取当前时间

Format 方法格式化输出日期字符串

获取当前的时间戳

时间戳转换为日期字符串（年-月-日 时:分:秒）

now.Format 把时间戳格式化成日期

日期字符串转换成时间戳

时间间隔

时间操作函数

定时器

参考文献

时间戳转换为日期字符串（年-月-日时:分:秒）