Go 时间格式化

在其他编程语言或 SQL 中格式化时间时,我们通常会写 "YYYY-MM-DD HH:mm:ss" 这类字母占位符。但如果在 Go 语言里写 t.Format("YYYY-MM-DD"),程序并不会输出具体的年月日,而是会原样打印出 "YYYY-MM-DD"。

这是因为 Go 语言没有采用字母占位符,而是规定使用一个固定的参考时间 "2006-01-02 15:04:05" 作为格式模板。无论是将时间格式化为字符串,还是反过来将字符串解析还原为时间对象,使用的都是同一套参考时间模板。

时间转字符串:Format()

在 Go 语言中,拿到一个 time.Time 时间对象后,如果我们想要将它转换为指定格式的字符串,可以调用 Format() 方法。

语法:

t.Format(layout)

说明:

Format() 方法接收一个模板字符串 layout(英文意为 “布局”),并返回格式化后的时间字符串。在编写 layout 模板时,我们必须使用 Go 语言指定的参考时间 “2006 年 01 月 02 日 15 点 04 分 05 秒” 来代表各个时间位置。

这串看似奇怪的数字应该怎么记呢?其实按照美式日期的排列习惯,它可以拆成 “01 月、02 日、下午 03 点、04 分、05 秒、06 年(2006 年)”,刚好是从 1 到 6 的递增顺子。其中下午 3 点换成 24 小时制就是 15 点,对应关系如下图所示。

Go 时间格式化参考模板与数字对应关系

模板中各个占位数字的具体含义如下:

  • 2006:代表 4 位数的年份;如果写成 06,则代表 2 位数的年份。
  • 01:代表 2 位数的月份,不足 2 位自动补 0;如果写成 1,则单数月不补 0。
  • 02:代表 2 位数的日期,不足 2 位自动补 0;如果写成 2,则单数日不补 0。
  • 15:代表 24 小时制的小时;如果写成 03,则代表 12 小时制的小时。
  • 04:代表 2 位数的分钟,不足 2 位自动补 0。
  • 05:代表 2 位数的秒数,不足 2 位自动补 0。
  • .000:跟在秒数 05 后面写成 05.000,代表保留 3 位毫秒小数。

Format() 方法常用的模板组合如下表所示。

时间格式化常用模板
模板 说明 输出示例
2006-01-02 15:04:05 标准日期时间(24 小时制) 2026-04-09 19:07:05
2006-01-02 15:04:05.000 精确到 3 位毫秒 2026-04-09 19:07:05.128
2006-01-02 仅保留年月日 2026-04-09
15:04:05 仅保留时分秒 19:07:05
2006/01/02 15:04 斜杠分隔,精确到分钟 2026/04/09 19:07
2006年01月02日 中文日期(补 0) 2026年04月09日
2006年1月2日 中文日期(不补 0) 2026年4月9日

注意: 在编写 24 小时制的时间模板时,小时的位置必须写成 15。如果我们误写成了 "2006-01-02 03:04:05",Go 会按照 12 小时制来格式化,导致晚上 19:00 被显示成 "07:00"。

示例 1:使用自定义模板格式化

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Date(2026, 4, 9, 19, 7, 5, 0, time.Local)

    fmt.Println(t.Format("2006-01-02 15:04:05"))
    fmt.Println(t.Format("2006-01-02"))
    fmt.Println(t.Format("2006年01月02日 15:04"))
    fmt.Println(t.Format("2006年1月2日"))
}

运行结果如下。

2026-04-09 19:07:05
2026-04-09
2026年04月09日 19:07
2026年4月9日

分析:

在这个例子中,模板中间的分隔符可以自由指定,无论是横杠 -、斜杠 / 还是中文的 “年”、“月”、“日” 都会原样保留。只要对应位置写对了参考时间里的占位数字,Format() 就会把它们替换成 t 实际的日期与时间。

比如月份和日期写成 01、02 时,会输出补零的 "04月09日";写成 1、2 时,则会输出不补零的 "4月9日"。

这里小伙伴们一定要记住,模板里的参考数字是 Go 语言固定死的,千万不要随便换成其他日期或字母占位符。

// 正确方式
s := t.Format("2006-01-02 15:04:05")

// 错误方式
s1 := t.Format("2026-01-01 12:00:00")
s2 := t.Format("YYYY-MM-DD HH:mm:ss")

如果把模板写成 "2026-01-01 12:00:00",Go 既认不出 2026,还会把其中的 02 错当成日期。同时,它又会把 12 拆成月份 1 和日期 2 去替换,最终输出一堆错乱数字。写成 "YYYY-MM-DD" 时,Go 找不到任何识别标记,只会把这些字母原样打印出来。

内置格式常量

每次格式化时间都要手敲一串 "2006-01-02 15:04:05",万一敲错一个数字就会导致结果错乱。为了减少手误,time 包预先定义了一批常用的标准格式常量,其中最常用的是以下 4 个。

语法:

t.Format(time.DateTime)
t.Format(time.DateOnly)
t.Format(time.TimeOnly)
t.Format(time.RFC3339)

说明:

前 3 个常量从 Go 1.20 开始内置,time.RFC3339 则是前后端接口与 JSON 数据里非常常见的国际标准格式:

  • time.DateTime:对应 "2006-01-02 15:04:05",用于输出完整的 “年-月-日 时:分:秒”。
  • time.DateOnly:对应 "2006-01-02",用于只输出 “年-月-日”。
  • time.TimeOnly:对应 "15:04:05",用于只输出 “时:分:秒”。
  • time.RFC3339:对应 "2006-01-02T15:04:05Z07:00",日期和时间中间带字母 T,末尾附带时区偏移(如 +08:00 或 Z)。

示例 2:使用内置格式常量

package main

import (
    "fmt"
    "time"
)

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

    fmt.Println(now.Format(time.DateTime))
    fmt.Println(now.Format(time.DateOnly))
    fmt.Println(now.Format(time.TimeOnly))
    fmt.Println(now.Format(time.RFC3339))
}

运行结果如下。

2026-11-12 08:45:00
2026-11-12
08:45:00
2026-11-12T08:45:00+08:00

分析:

now.Format(time.DateTime) 表示将 time.Now() 获取到的当前时间按标准日期时间格式输出,实际结果会随运行时刻变化。

平时只需要标准横杠分隔的日期时间,或者需要按国际标准输出接口时间时,我们优先使用这几个内置常量就可以了。这样既直观好读,又不用担心手敲参考数字出错;遇到中文日期或斜杠分隔等个性格式时,再手写自定义模板即可。

解析时间字符串:ParseInLocation()

前面介绍的 Format() 是把 time.Time 转为字符串。反过来,当我们从前端表单或配置文件读到一段日期字符串,想要把它还原为 time.Time 对象时,可以使用 time.ParseInLocation() 函数。

语法:

t, err := time.ParseInLocation(layout, value, loc)

说明:

该函数会返回解析后的 time.Time 对象和一个 error 错误值,它接收以下 3 个必选参数:

  • layout(必选):布局模板字符串,比如 "2006-01-02 15:04:05" 或常量 time.DateTime。它的格式结构必须与待解析的字符串完全一致。
  • value(必选):需要解析的时间字符串,比如 "2026-11-12 08:45:00"。
  • loc(必选):指定按哪个时区解析该字符串,平时传入 time.Local 即可按当前系统的本地时区解析。

示例 3:解析标准时间字符串

package main

import (
    "fmt"
    "time"
)

func main() {
    str := "2026-11-12 08:45:00"

    // 按本地时区解析标准时间字符串
    t, err := time.ParseInLocation(time.DateTime, str, time.Local)
    if err != nil {
        fmt.Println("解析失败:", err)
        return
    }

    fmt.Println(t)
    fmt.Printf("%d年%d月%d日\n", t.Year(), int(t.Month()), t.Day())
}

运行结果如下。

2026-11-12 08:45:00 +0800 CST
2026年11月12日

分析:

待解析的字符串 "2026-11-12 08:45:00" 是标准的 “年-月-日 时:分:秒” 结构,因此第 1 个参数直接传入常量 time.DateTime 就能成功还原为时间对象。

遇到斜杠 / 分隔或者只精确到分钟的自定义字符串时,我们需要手写一个和它严格对齐的模板来解析。

示例 4:解析自定义格式时间

package main

import (
    "fmt"
    "time"
)

func main() {
    str := "2026/07/20 14:30"
    layout := "2006/01/02 15:04"

    // 模板的分隔符与组成部分必须和字符串对齐
    t, err := time.ParseInLocation(layout, str, time.Local)
    if err != nil {
        fmt.Println("解析失败:", err)
        return
    }

    fmt.Println(t.Format(time.DateTime))
}

运行结果如下。

2026-07-20 14:30:00

分析:

在这个例子中,字符串 "2026/07/20 14:30" 使用斜杠分隔且没有秒数,因此模板 layout 也必须对应写成 "2006/01/02 15:04"。解析成功后,未提供的秒数会自动补 0。

同理,如果字符串只有日期 "2026-11-12",也不能拿带时分秒的 time.DateTime 去解析,而应该传入 time.DateOnly。一旦模板与字符串的格式对不上,函数返回的 err 就不会为 nil,因此小伙伴们记得配合 if err != nil 做好错误处理。

很多初学 Go 的小伙伴看到 time 包里还有一个参数更少的 time.Parse(layout, value) 函数,便习惯直接使用它来解析本地时间。但如果不注意时区,这一步非常容易埋下相差 8 小时的隐蔽问题,我们通过下面这个例子直观对比一下。

示例 5:对比解析时的时区差异

package main

import (
    "fmt"
    "time"
)

func main() {
    str := "2026-11-12 08:45:00"
    cstZone := time.FixedZone("CST", 8*3600)

    // 1. time.Parse() 默认按 UTC 零时区解析
    tUTC, _ := time.Parse(time.DateTime, str)

    // 2. time.ParseInLocation() 按指定时区解析
    tCST, _ := time.ParseInLocation(time.DateTime, str, cstZone)

    fmt.Println(tUTC)
    fmt.Println(tCST)
    fmt.Printf("相差秒数:%d\n", tUTC.Unix()-tCST.Unix())
}

运行结果如下。

2026-11-12 08:45:00 +0000 UTC
2026-11-12 08:45:00 +0800 CST
相差秒数:28800

分析:

从运行结果可以看出,面对同一个字符串 "2026-11-12 08:45:00",time.Parse() 默认把它当成了 +0000 UTC 零时区时间。而 time.ParseInLocation() 则准确解析为 +0800 CST 东八区北京时间。

将两者转为时间戳相减后,结果整整相差了 28800 秒,也就是 8 个小时。为了在不同运行环境下都能稳定看到这个差异,示例里显式构造了东八区 cstZone。平时在国内本地电脑上开发时,直接传入 time.Local 就可以了。

这里为了聚焦对比时区差异,我们在代码里使用 _ 省略了错误检查。实际写业务代码解析外部时间字符串时,小伙伴们记得依然要判断 err != nil。

常见问题

1. 为什么 Go 语言不使用 YYYY-MM-DD 这样的字母占位符?

在其他编程语言中,字母占位符很容易记混大小写。比如在 Java 中,大写 MM 表示月份、小写 mm 表示分钟。而在 Python 的 strftime() 中,%M 反而是分钟、%m 才是月份,稍不留神就会写错。

Go 语言直接拿一串固定的参考时间 "2006-01-02 15:04:05" 当模板。看到 2006 就知道是 4 位年份,看到 15 就知道是 24 小时制的小时,省去了记忆字母大小写规则的麻烦。

2. 什么时候可以直接使用 time.Parse() 来解析时间?

如果待解析的字符串本身已经带有时区标识,比如 time.RFC3339 格式的 "2026-11-12T08:45:00+08:00" 或以 Z 结尾的 UTC 时间,就可以使用 time.Parse()。它会直接读取字符串里的时区信息,不会出现 8 小时偏差。

但只要字符串里没有携带时区标识(如常见的 "2026-11-12 08:45:00"),为了避免时区错位,我们都应该统一使用 time.ParseInLocation()。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号