在其他编程语言或 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 点,对应关系如下图所示。

模板中各个占位数字的具体含义如下:
- 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()。
