Go时间与日期处理
Go 语言中的时间与日期基础类型
在 Go 语言中，时间与日期的处理主要依赖于 time 包。这个包提供了一系列用于操作时间和日期的函数与类型。其中最核心的类型是 time.Time，它代表了一个时间点，精确到纳秒级别。
time.Time 类型的零值表示 1970-01-01 00:00:00 +0000 UTC，也就是 Unix 时间的起始点。我们可以通过多种方式创建 time.Time 类型的实例。
获取当前时间
要获取当前的本地时间，我们可以使用 time.Now() 函数。示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println(now)
}
在上述代码中，time.Now() 返回一个 time.Time 类型的实例，代表当前的本地时间。输出的格式类似于 2023-11-01 14:30:00.123456789 +0800 CST，其中包含了年、月、日、时、分、秒、纳秒以及时区信息。
根据时间戳创建时间
Unix 时间戳是从 1970-01-01 00:00:00 UTC 到指定时间所经过的秒数或纳秒数。time.Unix 函数用于根据秒级时间戳创建 time.Time 实例，time.UnixNano 函数用于根据纳秒级时间戳创建实例。示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
// 秒级时间戳
sec := int64(1698837000)
t1 := time.Unix(sec, 0)
fmt.Println(t1)
// 纳秒级时间戳
nano := int64(1698837000123456789)
t2 := time.UnixNano(nano)
fmt.Println(t2)
}
在上述代码中，time.Unix(sec, 0) 根据秒级时间戳 1698837000 创建了一个时间实例，而 time.UnixNano(nano) 根据纳秒级时间戳 1698837000123456789 创建了另一个时间实例。
时间的格式化与解析
在实际应用中，我们经常需要将时间格式化为特定的字符串形式，或者将字符串解析为时间类型。time 包提供了强大的格式化和解析功能。
时间格式化
time.Time 类型的 Format 方法用于将时间格式化为字符串。格式化的布局字符串是基于一个参考时间 Mon Jan 2 15:04:05 MST 2006 来定义的。每个数字和字符都代表时间的一个特定部分。例如，2006 代表年份，01 代表月份，02 代表日期等。
以下是一些常见的时间格式化示例：
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
// 格式化成年月日 时分秒的形式
fmt.Println(now.Format("2006-01-02 15:04:05"))
// 只格式化成年月日
fmt.Println(now.Format("2006-01-02"))
// 格式化成分秒毫秒的形式
fmt.Println(now.Format("15:04:05.000"))
}
在上述代码中，now.Format("2006-01-02 15:04:05") 将当前时间格式化为 YYYY-MM-DD HH:MM:SS 的形式，now.Format("2006-01-02") 只保留了年、月、日，now.Format("15:04:05.000") 则突出了时、分、秒以及毫秒部分。
时间解析
time.Parse 函数用于将字符串解析为 time.Time 类型。它接受两个参数，第一个是布局字符串，第二个是要解析的字符串。布局字符串的格式与 Format 方法中的布局字符串一致。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
str := "2023-11-01 14:30:00"
layout := "2006-01-02 15:04:05"
t, err := time.Parse(layout, str)
if err != nil {
fmt.Println("解析错误:", err)
return
}
fmt.Println(t)
}
在上述代码中，time.Parse(layout, str) 尝试将字符串 2023-11-01 14:30:00 根据布局字符串 2006-01-02 15:04:05 解析为 time.Time 类型。如果解析失败，会返回错误信息。
时间的计算与比较
在处理时间和日期时，我们经常需要进行时间的计算，比如计算两个时间点之间的差值，或者在某个时间点上增加或减少一定的时间间隔。同时，也需要对不同的时间点进行比较。
时间间隔计算
time.Duration 类型表示两个时间点之间的时间间隔，它以纳秒为单位。time.Time 类型提供了 Sub 方法用于计算两个时间点之间的时间间隔。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
t1 := time.Date(2023, 11, 1, 14, 30, 0, 0, time.Local)
t2 := time.Date(2023, 11, 2, 14, 30, 0, 0, time.Local)
diff := t2.Sub(t1)
fmt.Println(diff.Hours())
}
在上述代码中，t2.Sub(t1) 计算了 t2 和 t1 之间的时间间隔，返回一个 time.Duration 类型的值。通过调用 diff.Hours() 方法，我们将时间间隔转换为小时数并输出。
时间增加与减少
time.Time 类型的 Add 方法用于在一个时间点上增加指定的时间间隔，AddDate 方法用于增加指定的年、月、日。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
// 增加 1 小时
afterOneHour := now.Add(1 * time.Hour)
fmt.Println(afterOneHour)
// 增加 1 天
afterOneDay := now.AddDate(0, 0, 1)
fmt.Println(afterOneDay)
}
在上述代码中，now.Add(1 * time.Hour) 在当前时间 now 上增加了 1 小时，now.AddDate(0, 0, 1) 则在当前时间上增加了 1 天。
时间比较
time.Time 类型提供了 Before、After 和 Equal 方法用于比较两个时间点的先后顺序或是否相等。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
t1 := time.Date(2023, 11, 1, 14, 30, 0, 0, time.Local)
t2 := time.Date(2023, 11, 2, 14, 30, 0, 0, time.Local)
fmt.Println(t1.Before(t2))
fmt.Println(t2.After(t1))
fmt.Println(t1.Equal(t1))
}
在上述代码中，t1.Before(t2) 判断 t1 是否在 t2 之前，t2.After(t1) 判断 t2 是否在 t1 之后，t1.Equal(t1) 判断 t1 是否与自身相等。
时区处理
在全球范围内，不同地区使用不同的时区。Go 语言的 time 包提供了对时区的支持，使得我们能够在不同时区之间进行时间转换和操作。
时区表示
time.Location 类型表示一个时区。time.LoadLocation 函数用于加载指定名称的时区，例如 time.LoadLocation("Asia/Shanghai") 加载上海所在的时区。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
fmt.Println("加载时区错误:", err)
return
}
now := time.Now().In(loc)
fmt.Println(now)
}
在上述代码中，time.LoadLocation("Asia/Shanghai") 加载了上海时区，time.Now().In(loc) 将当前时间转换到上海时区并输出。
时间转换
time.Time 类型的 In 方法用于将时间转换到指定的时区。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
loc1, err := time.LoadLocation("UTC")
if err != nil {
fmt.Println("加载 UTC 时区错误:", err)
return
}
loc2, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
fmt.Println("加载上海时区错误:", err)
return
}
utcTime := time.Date(2023, 11, 1, 14, 30, 0, 0, loc1)
shanghaiTime := utcTime.In(loc2)
fmt.Println("UTC 时间:", utcTime)
fmt.Println("上海时间:", shanghaiTime)
}
在上述代码中，我们首先创建了一个 UTC 时间 utcTime，然后通过 utcTime.In(loc2) 将其转换为上海时间 shanghaiTime 并输出。
日期相关操作
除了时间点的处理，Go 语言的 time 包也提供了一些与日期相关的操作，比如获取一周中的某一天，判断是否为闰年等。
获取一周中的某一天
time.Time 类型的 Weekday 方法返回一个 time.Weekday 类型的值，表示一周中的某一天。time.Weekday 是一个枚举类型，从 time.Sunday 到 time.Saturday。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
weekday := now.Weekday()
fmt.Println(weekday)
}
在上述代码中，now.Weekday() 返回当前时间是一周中的第几天，输出结果类似于 Wednesday。
判断是否为闰年
time.IsLeapYear 函数用于判断指定的年份是否为闰年。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
year := 2024
isLeap := time.IsLeapYear(year)
fmt.Println(isLeap)
}
在上述代码中，time.IsLeapYear(year) 判断 2024 年是否为闰年，并输出结果。
定时器与 ticker
在 Go 语言中，time 包还提供了定时器（Timer）和 ticker（Ticker）的功能，用于实现定时任务和周期性任务。
定时器
time.Timer 类型用于在指定的时间间隔后触发一个事件。time.NewTimer 函数用于创建一个定时器。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
timer := time.NewTimer(2 * time.Second)
fmt.Println("定时器已启动")
<-timer.C
fmt.Println("定时器触发")
}
在上述代码中，time.NewTimer(2 * time.Second) 创建了一个定时器，2 秒后触发事件。通过 <-timer.C 阻塞当前 goroutine，直到定时器触发事件，然后输出 "定时器触发"。
ticker
time.Ticker 类型用于按照指定的时间间隔周期性地触发事件。time.NewTicker 函数用于创建一个 ticker。
示例代码如下：
package main
import (
"fmt"
"time"
)
func main() {
ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()
for {
<-ticker.C
fmt.Println("ticker 触发")
}
}
在上述代码中，time.NewTicker(1 * time.Second) 创建了一个 ticker，每隔 1 秒触发一次事件。通过 for { <-ticker.C } 循环，不断接收 ticker 触发的事件并输出 "ticker 触发"。注意，在使用完 ticker 后，需要通过 ticker.Stop() 停止 ticker，以避免资源泄漏。
通过对以上 Go 语言中时间与日期处理的各个方面的学习，开发者可以在实际项目中灵活、高效地处理与时间和日期相关的业务逻辑，无论是简单的时间格式化，还是复杂的跨时区操作以及定时任务等场景，都能够应对自如。