概述

        在上一节的内容中，我们介绍了Go的Gob，包括：Gob简介、Gob编码、Gob解码等。在本节中，我们将介绍Go的时间日期。Go语言提供了一套强大的时间日期处理库，使得处理时间和日期变得简单和高效。Go语言中处理日期和时间的常用方式是使用time包，这个包提供了许多用于日期和时间操作的功能，包括：获取当前时间、格式化时间、计算时间差、处理时区等。

time包

        time包提供了许多用于处理日期和时间的函数，下面是一些常用的函数。

        time.Now(): 返回当前时间，类型为time.Time。

        time.Parse(layout, value): 将字符串解析为时间，并返回时间对象。layout是日期时间的布局字符串，指定了输入字符串的格式。

        time.Date(year, month, day, hour, min, sec, nanosec, loc): 返回一个指定日期和时间的时间对象。

        time.Add(d duration): 返回一个时间对象加上给定持续时间的时间对象。

        time.Sub(t time.Time): 返回两个时间之间的时间差。

        time.Since(t time.Time): 返回从指定时间到当前时间的持续时间。

        time.Until(t time.Time): 返回从当前时间到指定时间的持续时间。

        time.In(loc *time.Location): 将时间转换为指定时区的时间。

        time.Now().Format(format string): 将当前时间格式化为指定的字符串形式。format是日期时间的格式化字符串，用于指定输出的格式。

        time.ParseDuration(durationStr string) duration: 将字符串解析为持续时间，并返回持续时间对象。

格式化日期

        在下面的示例代码中，我们首先通过time.Now()函数获取到了当前时间。然后，将当前时间通过Format()函数格式化成了指定的字符串形式。最后，我们打印输出了这个字符串形式的时间。

package main
import (
 "fmt"
 "time"
)
func main() {
    // 获取当前时间
    currentTime := time.Now()
    // 输出：2023-11-26 15:01:26.4162829 +0800 CST m=+0.002639401
    fmt.Println(currentTime)
    // 格式化时间
    timeString := currentTime.Format("2006-01-02 15:04:05")
    // 输出：2023-11-26 15:01:26
    fmt.Println(timeString)
}

日期字符串解析

        在下面的示例代码中，我们使用time.Parse()函数将字符串形式的日期解析成了time.Time类型的时间。

package main
import (
 "fmt"
 "time"
)
func main() {
    // 日期字符串解析为时间对象
    dateString := "2023-11-26 15:50:45"
    // 格式化字符串，必须与输入的日期字符串格式匹配
    layout := "2006-01-02 15:04:05"
    date, err := time.Parse(layout, dateString)
    if err != nil {
        fmt.Println(err)
        return
    }
    // 输出：2023-11-26 15:50:45 +0000 UTC
    fmt.Println(date)
}

计算日期差

        在下面的示例代码中，我们首先通过time.Now()函数获取到了当前时间，并作为开始时间。然后，将开始时间添加6个小时作为结束时间。接下来，我们通过time.Sub()函数计算了开始时间与结束时间的时间差。最后，我们还计算了开始时间到当前时间的时间差、当前时间到结束时间的时间差，并进行了打印输出。

package main
import (
 "fmt"
 "time"
)
func main() {
    startTime := time.Now()
    // 结束时间为开始时间后6个小时
    endTime := startTime.Add(6 * time.Hour)
    duration := endTime.Sub(startTime)
    // 输出时间差的小时数，输出：6
    fmt.Println(duration.Hours())
    duration = time.Since(startTime)
    // 计算开始时间到当前时间的时间差，输出：531.6µs
    fmt.Println(duration)
    duration = time.Until(endTime)
    // 计算当前时间到结束时间的时间差，输出：5h59m59.9994684s
    fmt.Println(duration)
}

时区操作

        在下面的示例代码中，我们使用time.LoadLocation函数加载了名为"America/New_York"的时区信息。如果加载成功，我们将当前时区的时间转换为纽约时区的时间。

package main
import (
 "fmt"
 "time"
)
func main() {
    // 加载指定时区信息
    location, err := time.LoadLocation("America/New_York")
    if err != nil {
        fmt.Println(err)
        return
    }
    currenTime := time.Now()
    // 输出当前时区的时间：2023-11-26 15:26:11.3579989 +0800 CST m=+0.003050601
    fmt.Println(currenTime)
    // 将当前时间转换为指定时区的时间
    currentTimeLoc := time.Now().In(location)
    // 输出纽约时区的时间：2023-11-26 02:26:11.3706785 -0500 EST
    fmt.Println(currentTimeLoc)
}

定时任务

        在Go语言中，time.Tick函数用于定期生成时间间隔。它返回一个通道，每当指定的时间间隔过去后，通道上就会收到一个时间值。time.Tick函数的语法如下：

          func Tick(d Duration) <-chan time.Time

        其中，d参数指定了生成时间间隔的持续时间。函数返回一个通道，每当持续时间过去后，就会在通道上收到一个时间值。

        在下面的示例代码中，我们使用time.Tick函数创建了一个每2秒生成一个时间值的通道。通过使用for range循环迭代该通道，我们可以每隔2秒打印出当前时间的值。

package main
import (
 "fmt"
 "time"
)
func main() {
    // 每隔2秒，输出一次当前时间
    ticker := time.Tick(2 * time.Second)
    for range ticker {
        fmt.Println(time.Now())
    }
}