在Golang中使用日期时间

Go日期时间教程展示了如何在Golang中使用日期时间。time包提供测量和显示时间的功能。

定义

日历时间，也称为绝对时间，是时间连续体中的一个点，例如欧洲中部时间2021年7月29日13:02:5。时间间隔是两个日历时间之间时间连续体的连续部分；例如2020年2月20日15:00到19:00之间的小时。经过时间是间隔的长度，例如38分钟。

时间量是经过时间的总和。经过的时间不需要是连续的。当这项工作花了我们11个小时时，我们可能会在不同的日子工作。周期是两个事件之间间隔的经过时间。CPU时间是中央处理器(CPU)用于处理计算机程序或操作系统指令的时间量。它以时钟滴答或秒为单位进行测量。epoch是被选为特定时代起源的时间瞬间。Unixepoch是1970年1月1日的00:00:00UTC（或1970-01-01T00:00:00ZISO8601）。

挂钟时间，也称为真实世界时间或挂钟时间，指的是由计时器（如手表或挂钟）确定的经过时间。（挂钟的参考是如何该术语最初得名。）Walltime不同于通过计算微处理器时钟脉冲或周期来测量的时间。

$ go version
go version go1.18.1 linux/amd64

我们使用Go版本1.18。

转到当前时间示例

以下示例打印当前日期和时间。

package main

import (
    "fmt"
    "time"
)

func main() {

    now := time.Now()
    fmt.Println("Current datetime:", now)
}

该示例使用Now打印当前时间。

$ go run main.go
Current datetime: 2022-05-29 17:46:47.069217048 +0200 CEST m=+0.000013004

到UTC时间

我们的星球是一个球体；它绕着它的轴旋转。地球向东自转，所以太阳在不同的时间在不同的地方升起。地球大约每24小时自转一次。因此，世界被划分为24个时区。每个时区都有不同的当地时间。夏令时通常会进一步修改本地时间。

有一个全球时间的实用需求。一个全球时间有助于避免时区和夏令时的混淆。UTC（通用协调时间）被选为主要时间标准。UTC用于航空、天气预报、飞行计划、空中交通管制许可和地图。与当地时间不同，UTC不会随着季节的变化而变化。

$ timedatectl
               Local time: Ne 2022-05-29 17:48:07 CEST
           Universal time: Ne 2022-05-29 15:48:07 UTC
                 RTC time: Ne 2022-05-29 15:48:07
                Time zone: Europe/Bratislava (CEST, +0200)
System clock synchronized: yes
              NTP service: active
          RTC in local TZ: no

我们的时区是中欧夏令时(CEST)。UTC偏移量，即本地时间和UTC时间之间的差异，对于我们的区域来说是2小时。

package main

import (
     "fmt"
     "time"
)

func main() {

     utc := time.Now().UTC()
     fmt.Println(utc)
}

该示例使用UTC函数打印UTC时间。

$ go run main.go
2022-05-29 15:50:07.413562417 +0000 UTC

转到日期时间部分

在下面的示例中，我们打印当前日期时间的各个部分。

package main

import (
    "fmt"
    "time"
)

func main() {

    now := time.Now()

    fmt.Println("Year:", now.Year())
    fmt.Println("Month:", now.Month())
    fmt.Println("Day:", now.Day())
    fmt.Println("Hour:", now.Hour())
    fmt.Println("Minute:", now.Minute())
    fmt.Println("Second:", now.Second())
    fmt.Println("Nanosecond:", now.Nanosecond())
}

我们分别用相应的函数打印年、月、日、时、分、秒、纳秒。

$ go run main.go
Year: 2022
Month: May
Day: 29
Hour: 17
Minute: 50
Second: 38
Nanosecond: 266573694

转到日期函数

time.Date函数允许从给定时刻int时间创建日期时间。

package main

import (
     "fmt"
     "time"
)

func main() {
     t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
     fmt.Printf("Go launch date: %s\n", t.Local())
}

我们将年、月、日、小时、分钟、秒、纳秒和位置参数传递给time.Date函数。

$ go run main.go
Go launch date: 2009-11-11 00:00:00 +0100 CET

格式化日期时间

Go不使用典型的yyyy-mm-dd格式说明符；它使用以下参考日期时间格式：

Mon Jan 2 15:04:05 -0700 MST 2006

我们格式化时间如何构造这个特定的参考日期时间。

package main

import (
    "fmt"
    "time"
)

func main() {

    now := time.Now()

    fmt.Println("Time: ", now.Format("15:04:05"))
    fmt.Println("Date:", now.Format("Jan 2, 2006"))
    fmt.Println("Timestamp:", now.Format(time.Stamp))
    fmt.Println("ANSIC:", now.Format(time.ANSIC))
    fmt.Println("UnixDate:", now.Format(time.UnixDate))
    fmt.Println("Kitchen:", now.Format(time.Kitchen))
}

该示例以自定义和预定义格式显示当前时间。

fmt.Println("Date:", now.Format("Jan 2, 2006"))

这是自定义日期时间格式的示例。

fmt.Println("ANSIC:", now.Format(time.ANSIC))

这是预定义格式的示例。

$ go run main.go
Time:  17:51:45
Date: May 29, 2022
Timestamp: May 29 17:51:45
ANSIC: Sun May 29 17:51:45 2022
UnixDate: Sun May 29 17:51:45 CEST 2022
Kitchen: 5:51PM

去解析日期时间

Parse函数解析格式化的字符串并返回它表示的时间值。

func Parse(layout, value string) (Time, error)

布局通过显示参考时间来定义格式。预定义布局ANSIC、UnixDate、RFC3339等描述了参考时间的标准和方便的表示。

package main

import (
     "fmt"
     "log"
     "time"
)

func main() {

     vals := []string{"2021-07-28", "2020-11-12", "2019-01-05"}

     for _, val := range vals {

          t, err := time.Parse("2006-01-02", val)

          if err != nil {

               log.Fatal(err)
          }

          fmt.Println(t)
     }
}

该示例解析三个日期值。

$ go run main.go
2021-07-28 00:00:00 +0000 UTC
2020-11-12 00:00:00 +0000 UTC
2019-01-05 00:00:00 +0000 UTC

Go日期时间算术

要添加或减去日期时间，我们可以使用Add和AddDate函数。

package main

import (
     "fmt"
     "time"
)

func main() {

     now := time.Now()

     t1 := now.Add(time.Hour * 27)
     fmt.Println(t1.Format(time.UnixDate))

     t2 := now.AddDate(2, 10, 11)
     fmt.Println(t2.Format(time.UnixDate))

     t3 := now.Add(-time.Hour * 6)
     fmt.Println(t3.Format(time.UnixDate))
}

在代码示例中，我们执行三个算术运算。

t1 := now.Add(time.Hour * 27)

我们增加了27小时。

t2 := now.AddDate(2, 10, 11)

我们加上2年10个月11天。

t3 := now.Add(-time.Hour * 6)

我们减去6小时。

$ go run main.go
Mon May 30 20:52:29 CEST 2022
Wed Apr  9 17:52:29 CEST 2025
Sun May 29 11:52:29 CEST 2022

Godatetime持续时间

持续时间是两个瞬间之间经过的时间。

type Duration int64

Go中的Duration类型将两个瞬间之间经过的时间表示为int64纳秒计数。

func (t Time) Sub(u Time) Duration

Sub函数返回两个时间点之间经过的时间。

package main

import (
     "fmt"
     "time"
)

func main() {

     t1 := time.Date(2020, time.November, 10, 23, 0, 0, 0, time.UTC)
     t2 := time.Date(2021, time.July, 28, 16, 22, 0, 0, time.UTC)

     elapsed := t2.Sub(t1)

     fmt.Println(elapsed)
}

该示例计算两个时刻之间经过的时间。

$ go run main.go
6233h22m0s

package main

import (
     "fmt"
     "time"
)

func main() {

     t2 := time.Now()

     year, _, _ := t2.Date()
     t1 := time.Date(year, 0, 0, 0, 0, 0, 0, time.Local)

     elapsed := time.Since(t1)

     fmt.Println(elapsed)
}

Since函数返回自指定日期时间以来经过的时间。它是time.Now().Sub(t)的简写。

$ go run main.go
4336h53m3.593593645s

去日期时间位置

位置将时间瞬间映射到当时使用的区域。

func (t Time) In(loc *Location) Time

In函数返回具有特定位置的时间。

package main

import (
     "fmt"
     "log"
     "time"
)

func main() {

     names := []string{
          "Local",
          "UTC",
          "Pacific/Galapagos",
          "Europe/Budapest",
          "Europe/Moscow",
          "Asia/Vladivostok",
          "Antarctica/Vostok",
          "America/New_York",
          "Africa/Tripoli",
     }

     now := time.Now()

     for _, name := range names {

          loc, err := time.LoadLocation(name)

          if err != nil {
               log.Fatal(err)
          }

          t := now.In(loc)

          fmt.Println(loc, ": ", t)
     }
}

示例获取当前本地时间，并判断不同地点对应的时间。

$ go run main.go
Local :  2022-05-29 17:53:24.652877602 +0200 CEST
UTC :  2022-05-29 15:53:24.652877602 +0000 UTC
Pacific/Galapagos :  2022-05-29 09:53:24.652877602 -0600 -06
Europe/Budapest :  2022-05-29 17:53:24.652877602 +0200 CEST
Europe/Moscow :  2022-05-29 18:53:24.652877602 +0300 MSK
Asia/Vladivostok :  2022-05-30 01:53:24.652877602 +1000 +10
Antarctica/Vostok :  2022-05-29 21:53:24.652877602 +0600 +06
America/New_York :  2022-05-29 11:53:24.652877602 -0400 EDT
Africa/Tripoli :  2022-05-29 17:53:24.652877602 +0200 EET

GoUnix时间

Unix时间是自Unix纪元以来的秒数。Unix时间广泛用于计算。

package main

import (
     "fmt"
     "time"
)

func main() {

     timestamp := time.Now().Unix()
     fmt.Printf("%d\n", timestamp)
}

我们使用Unix函数获取Unix时间。

$ go run main.go
1653839627

进行日期时间比较

为了比较日期时间，我们使用了Equal、Before和After函数。

package main

import (
     "fmt"
     "time"
)

func main() {

     var t1 = time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
     var t2 = time.Date(2021, time.July, 28, 16, 22, 0, 0, time.UTC)
     var t3 = time.Date(2021, time.July, 28, 16, 22, 0, 0, time.UTC)

     if t1.Equal(t2) {

          fmt.Println("t1 and t2 are equal")
     } else {

          fmt.Println("t1 and t2 are not equal")
     }

     if t2.Equal(t3) {

          fmt.Println("t2 and t3 are equal")
     } else {

          fmt.Println("t2 and t3 are not equal")
     }

     if t1.Before(t2) {

          fmt.Println("t1 is before t2")
     }

     if t3.After(t1) {

          fmt.Println("t3 is after t1")
     }
}

在代码示例中，我们比较了三个日期时间。

$ go run main.go
t1 and t2 are not equal
t2 and t3 are equal
t1 is before t2
t3 is after t1

在本教程中，我们使用了Go中的日期和时间。

列出所有Go教程。