Golang time库时间处理与格式化示例

P粉602998670

发布时间：2025-09-04 08:30:02

1009人浏览过

来源于php中文网

原创

Go语言中时间处理的核心是time.Time类型和“参考时间”Mon Jan 2 15:04:05 MST 2006，用于格式化和解析；通过time.Now()获取当前时间，Parse()和Format()进行字符串与时间的转换，Add()和Sub()实现时间加减，Before()、After()、Equal()用于比较；推荐使用UTC存储和传输时间，展示时再转换为本地时区，避免时区陷阱。

golang time库时间处理与格式化示例

在Go语言中，处理时间与格式化是日常开发中绕不开的话题，

time

库就是为此而生。它提供了一套直观且强大的API，让我们能够轻松地获取当前时间、解析字符串时间、将时间格式化成各种我们需要的样式，甚至进行复杂的时区转换和时间计算。掌握它，能让你的程序在处理时间维度的数据时更加健壮和灵活。

time

库的核心在于

time.Time

类型，它代表了某个特定的时间点。我们日常与时间打交道，无非就是几个场景：获取当前时间、把字符串变成时间、把时间变成字符串，以及时间之间的加减比较。

获取当前时间，很简单，

time.Now()

就能搞定，它返回的是当前系统的本地时间。

package main

import (
    "fmt"
    "time"
)

func main() {
    currentTime := time.Now()
    fmt.Println("当前时间:", currentTime)
}

将字符串解析成时间对象，这稍微有点讲究，因为字符串的格式千变万化。Go语言在这里引入了一个非常独特且令人印象深刻（或者说，初次接触时有点懵）的“参考时间”概念，也就是

Mon Jan 2 15:04:05 MST 2006

。这个日期本身并不重要，重要的是它各个组成部分代表的含义：

Mon

代表星期几，

Jan

代表月份，

代表日期，

代表小时（24小时制），

代表分钟，

代表秒，

MST

代表时区，

代表年份。当你需要解析一个特定格式的字符串时，你需要提供一个与该字符串格式完全匹配的“参考时间”布局字符串。比如，如果你有一个

"2023-10-27 10:30:00"

这样的字符串，那么你的布局字符串就应该是

"2006-01-02 15:04:05"

。

立即学习“go语言免费学习笔记（深入）”；

package main

import (
    "fmt"
    "time"
)

func main() {
    timeStr := "2023-10-27 10:30:00"
    layout := "2006-01-02 15:04:05"
    parsedTime, err := time.Parse(layout, timeStr)
    if err != nil {
        fmt.Println("解析时间失败:", err)
        return
    }
    fmt.Println("解析后的时间:", parsedTime)

    // 如果字符串没有时区信息，time.Parse默认会解析为UTC时间
    // 但如果布局字符串中包含时区信息，则会按照该时区解析
    timeStrWithZone := "2023-10-27 10:30:00 +0800"
    layoutWithZone := "2006-01-02 15:04:05 -0700" // -0700 对应 MST
    parsedTimeWithZone, err := time.Parse(layoutWithZone, timeStrWithZone)
    if err != nil {
        fmt.Println("解析带时区的时间失败:", err)
        return
    }
    fmt.Println("解析带时区的时间:", parsedTimeWithZone)
}

反过来，将

time.Time

对象格式化成字符串，也是用

Format()

方法，同样需要那个“参考时间”作为布局字符串。你想要什么格式，就用“参考时间”的相应部分来构建。

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Now()
    // 常见的日期时间格式
    fmt.Println("格式化为 YYYY-MM-DD HH:MM:SS:", t.Format("2006-01-02 15:04:05"))
    // 只有日期
    fmt.Println("格式化为 YYYY/MM/DD:", t.Format("2006/01/02"))
    // 只有时间
    fmt.Println("格式化为 HH:MM:SS:", t.Format("15:04:05"))
    // RFC3339 格式
    fmt.Println("格式化为 RFC3339:", t.Format(time.RFC3339))
}

至于时间加减，Go提供了

time.Duration

类型来表示一段时间间隔。你可以用它来给时间对象增加或减少时间。比较时间则有

Before()

、

After()

和

Equal()

方法。

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Now()
    // 增加1小时30分钟
    futureTime := t.Add(1*time.Hour + 30*time.Minute)
    fmt.Println("当前时间:", t)
    fmt.Println("未来时间 (1小时30分钟后):", futureTime)

    // 减去24小时 (一天前)
    pastTime := t.Add(-24 * time.Hour)
    fmt.Println("过去时间 (一天前):", pastTime)

    // 计算两个时间点之间的差值
    duration := futureTime.Sub(t)
    fmt.Println("时间差:", duration)

    // 比较时间
    fmt.Println("未来时间在当前时间之前吗?", futureTime.Before(t))
    fmt.Println("未来时间在当前时间之后吗?", futureTime.After(t))
    fmt.Println("未来时间与当前时间相等吗?", futureTime.Equal(t))
}

Go语言中时间格式化字符串的正确姿势是什么？

在Go语言中，时间格式化字符串的“正确姿势”其实就是理解并熟练运用那个独特的“参考时间”：

Mon Jan 2 15:04:05 MST 2006

。初次接触Go的

time

库，这个神秘的日期着实让我困惑了一阵子，它既不是常见的

strftime

或

SimpleDateFormat

那样的符号占位符，也不是Unix时间戳。但一旦你理解了其背后的逻辑，你会发现它异常直观和强大。

这个“参考时间”的每个数字和字母都对应着一个特定的时间元素：

```
2006
```
-> 年 (Year)
```
01
```
-> 月 (Month, 补零)
```
Jan
```
-> 月份名称 (January)
```
02
```
-> 日 (Day, 补零)
```
Mon
```
-> 星期几名称 (Monday)
```
15
```
-> 小时 (Hour, 24小时制, 补零)
```
03
```
-> 小时 (Hour, 12小时制, 补零)
```
04
```
-> 分钟 (Minute, 补零)
```
05
```
-> 秒 (Second, 补零)
```
.000
```
或
```
.999
```
-> 毫秒、微秒、纳秒
```
PM
```
或
```
PM
```
-> 上午/下午指示符 (需要与12小时制的小时配合使用)
```
MST
```
-> 时区名称 (Mountain Standard Time)
```
-0700
```
或
```
-07
```
-> 时区偏移量 (UTC-7小时)

所以，当你想要将

time.Time

对象格式化成字符串时，你不是提供一个描述你想要什么格式的模式，而是提供一个“示例”，告诉Go如果那个“参考时间”被格式化成你想要的样式，它会是什么样子。Go会根据你提供的这个“示例”来推断并格式化你的实际时间对象。

例如，如果你想要

YYYY-MM-DD HH:MM:SS

这样的格式，你就用参考时间构建一个

2006-01-02 15:04:05

的字符串作为布局。如果你想要

DD/MM/YYYY

，那就是

02/01/2006

。

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Now()

    // 格式化为常见的日期时间格式 (例如：2023-10-27 10:30:00)
    fmt.Println("标准格式:", t.Format("2006-01-02 15:04:05"))

    // 格式化为只有日期 (例如：2023/10/27)
    fmt.Println("日期格式:", t.Format("2006/01/02"))

    // 格式化为12小时制带AM/PM (例如：10:30:00 PM)
    fmt.Println("12小时制:", t.Format("03:04:05 PM"))

    // 格式化为带毫秒和时区偏移 (例如：2023-10-27T10:30:00.123+08:00)
    // 注意：Go内置了time.RFC3339等常量，可以直接使用，非常方便
    fmt.Println("RFC3339:", t.Format(time.RFC3339))

    // 如果你想要自定义的毫秒精度，比如只显示到毫秒
    fmt.Println("带毫秒:", t.Format("2006-01-02 15:04:05.000"))

    // 只有月份和年份
    fmt.Println("年月:", t.Format("January 2006"))
}

这种设计虽然初见时有些反直觉，但它的好处是极高的灵活性和可读性。你不需要记住一堆晦涩的格式化符号，只需要记住一个日期，然后用这个日期来“拼”出你想要的格式。

医真AI+开放平台

医真AI+ 医学AI开放平台

下载

Go语言中如何进行时间加减运算及比较？

Go语言中进行时间加减和比较运算，依赖于

time.Duration

类型和

time.Time

类型的方法，这套API设计得非常清晰和直观。

time.Duration

是一个

int64

类型，它代表了两个时间点之间的时间间隔，单位是纳秒。Go语言提供了一些预定义的常量来方便地创建

Duration

，比如

time.Second

time.Minute

time.Hour

等。

时间加减运算：

time.Time

类型有两个主要方法用于时间加减：

```
Add(d Duration) Time
```
: 返回一个在原时间基础上增加
```
d
```
时长的新时间对象。
```
Sub(t Time) Duration
```
: 返回当前时间与另一个时间
```
t
```
之间的差值（时长）。

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println("当前时间:", now.Format("2006-01-02 15:04:05"))

    // 增加时长
    oneHourLater := now.Add(time.Hour)
    fmt.Println("一小时后:", oneHourLater.Format("2006-01-02 15:04:05"))

    twoDaysAndHalfHourLater := now.Add(2*24*time.Hour + 30*time.Minute)
    fmt.Println("两天半小时后:", twoDaysAndHalfHourLater.Format("2006-01-02 15:04:05"))

    // 减去时长 (通过Add负值Duration实现)
    yesterday := now.Add(-24 * time.Hour)
    fmt.Println("昨天此时:", yesterday.Format("2006-01-02 15:04:05"))

    // 计算时间差
    durationBetween := twoDaysAndHalfHourLater.Sub(now)
    fmt.Printf("两天半小时后与当前时间差: %s (%.2f 小时)\n", durationBetween, durationBetween.Hours())

    // 如果Sub的结果是负数，表示第一个时间点在第二个时间点之前
    negativeDuration := now.Sub(twoDaysAndHalfHourLater)
    fmt.Printf("当前时间与两天半小时后时间差: %s (%.2f 小时)\n", negativeDuration, negativeDuration.Hours())
}

time.Duration

还提供了

Hours()

Minutes()

Seconds()

Milliseconds()

Microseconds()

Nanoseconds()

等方法，方便将时长转换为常用单位的浮点数。

时间比较运算：

time.Time

类型提供了三个方法用于比较两个时间点：

```
Before(u Time) bool
```
: 如果当前时间在
```
u
```
之前，返回
```
true
```
。
```
After(u Time) bool
```
: 如果当前时间在
```
u
```
之后，返回
```
true
```
。
```
Equal(u Time) bool
```
: 如果两个时间点相等，返回
```
true
```
。需要注意的是，
```
Equal
```
方法会考虑时区和纳秒精度，这意味着即使两个时间点代表的墙上时间相同，但如果时区或纳秒精度不同，它们可能不被认为是
```
Equal
```
的。通常，如果你只关心日期部分或特定精度，可能需要先对时间进行截断或转换。

package main

import (
    "fmt"
    "time"
)

func main() {
    t1 := time.Date(2023, time.October, 27, 10, 0, 0, 0, time.UTC)
    t2 := time.Date(2023, time.October, 27, 11, 0, 0, 0, time.UTC)
    t3 := time.Date(2023, time.October, 27, 10, 0, 0, 0, time.UTC)

    fmt.Printf("t1: %s, t2: %s, t3: %s\n", t1, t2, t3)

    fmt.Println("t1 在 t2 之前吗?", t1.Before(t2)) // true
    fmt.Println("t1 在 t2 之后吗?", t1.After(t2))  // false
    fmt.Println("t1 与 t3 相等吗?", t1.Equal(t3))  // true

    // 考虑精度和时区对Equal的影响
    t4 := time.Date(2023, time.October, 27, 10, 0, 0, 1, time.UTC) // 纳秒不同
    fmt.Println("t1 与 t4 相等吗 (纳秒不同)?", t1.Equal(t4)) // false

    t5 := time.Date(2023, time.October, 27, 10, 0, 0, 0, time.Local) // 时区不同
    // 假设本地时区不是UTC，那么t1和t5的墙上时间可能相同，但内部表示不同
    // 最好先转换为同一时区再比较，例如都转为UTC
    fmt.Println("t1 (UTC) 与 t5 (Local) 相等吗?", t1.Equal(t5)) // false，因为时区不同，即使墙上时间相同
    fmt.Println("t1 与 t5 (转换为UTC) 相等吗?", t1.Equal(t5.In(time.UTC))) // 转换为UTC后再比较
}

在实际开发中，尤其是在进行精确比较时，务必注意

time.Time

对象的时区信息。

Golang处理时区问题有哪些常见陷阱和最佳实践？

时区问题在任何编程语言中都是一个令人头疼的领域，Go语言的

time

库虽然提供了强大的支持，但也存在一些常见的陷阱。理解这些陷阱并遵循最佳实践，能有效避免数据不一致或时间错乱的问题。

常见陷阱：

time.Parse

的默认时区： 如果你的布局字符串中没有包含时区信息（例如

"2006-01-02 15:04:05"

），

time.Parse

默认会将解析出来的

time.Time

对象设置为

time.UTC

时区。这可能与你期望的本地时区行为不符。

timeStr := "2023-10-27 10:00:00"
layout := "2006-01-02 15:04:05"
t, _ := time.Parse(layout, timeStr)
fmt.Println("解析结果 (默认UTC):", t) // 会显示UTC时区
fmt.Println("解析结果 (本地时区):", t.Local()) // 如果你期望的是本地时间，需要手动转换

```
time.Now()
```
返回本地时间：
```
time.Now()
```
返回的是当前系统的本地时间，这在某些场景下很方便，但在跨系统、跨时区的数据交换或存储时，可能会导致问题。例如，服务器A在东八区，服务器B在零时区，
```
time.Now()
```
在两台服务器上会得到不同的时间点（墙上时间）。

不正确的时区加载： 使用

time.LoadLocation()

加载时区时，如果提供的时区名称不正确或系统上没有安装对应的时区数据，它会返回一个错误，或者默认使用UTC。在一些精简的容器镜像中，时区数据可能不完整。

// 假设 "Asia/Shanghai" 在系统上不存在或拼写错误
loc, err := time.LoadLocation("Asia/ShangHai") // 注意这里拼写错误
if err != nil {
    fmt.Println("加载时区失败:", err) // 会报错
    // 此时 loc 可能是 UTC
} else {
    fmt.Println("加载时区成功:", loc.String())
}

```
time.Date
```
创建时间时的时区参数：
```
time.Date(year, month, day, hour, min, sec, nsec, loc *Location)
```
的最后一个参数
```
loc
```
决定了创建时间的时区。如果传入
```
nil
```
，它会 panic。如果你传入
```
time.UTC
```
或
```
time.Local
```
，那没问题。但如果你传入一个通过
```
time.LoadLocation
```
加载的自定义时区，要确保加载成功。

最佳实践：

统一使用UTC进行存储和传输： 这是处理时区问题的黄金法则。在数据库中存储时间、在API之间传输时间时，始终使用UTC时间。这样可以避免因客户端或服务器时区设置不同导致的时间混乱。

将本地时间转换为UTC：
```
t.UTC()
```
将UTC时间转换为本地时间：
```
t.Local()
```
将UTC时间转换为指定时区：
```
t.In(location)
```

// 获取当前UTC时间
utcNow := time.Now().UTC()
fmt.Println("当前UTC时间:", utcNow)

// 将字符串解析为UTC时间（如果字符串本身不带时区信息）
timeStr := "2023-10-27 10:00:00"
layout := "2006-01-02 15:04:05"
parsedTimeUTC, _ := time.Parse(layout, timeStr) // 默认UTC
fmt.Println("解析字符串为UTC:", parsedTimeUTC)

// 如果字符串带时区信息，解析后转换为UTC
timeStrWithZone := "2023-10-27 10:00:00 +0800"
layoutWithZone := "2006-01-02 15:04:05 -0700"
t, _ := time.Parse(layoutWithZone, timeStrWithZone)
fmt.Println("解析带时区字符串并转换为UTC:", t.UTC())