golang time.Time 时间格式 format 布局字符 layout 整理

go语言中的时间格式字符串和我们常见的其他语言不太一样， 他的格式化字符串是一个时间，即2006-01-02 15:04:05 ， 细心的你可能会发现，这个是一个很特别的时间， 他的每一段都是唯一的，这个特别的时间的格式和我们常见的其他语言中的时间格式字符串 Y-m-d H:i:s  的效果是一样的。

go语言中的时间格式布局字符串的组成部分的摘要：

年:  "2006" "06"    这里年份的2种表示 2006表示4位年份， 06表示2位年份

月份:  "Jan" "January" "01" "1"     注意这里的代表月份的时间布局 有英文也有数字

星期几:  "Mon" "Monday"

一个月的哪一天:  "2" "_2" "02"

一年中的哪一天:   "__2" "002"

时:   "15" "3" "03" (PM or AM)

分:   "4" "04"

秒:   "5" "05"

AM/PM标记:  "PM"

数字时区偏移格式如下：

"-0700" ±hhmm

"-07:00" ±hh:mm

"-07" ±hh

"-070000" ±hhmmss

"-07:00:00" ±hh:mm:ss

time包中内置的时间格式常量

对于下面这些时间格式，我们直接 time.XXX 即可调用，不需要自己写

const (
	Layout      = "01/02 03:04:05PM '06 -0700" // The reference time, in numerical order.
	ANSIC       = "Mon Jan _2 15:04:05 2006"
	UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
	RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
	RFC822      = "02 Jan 06 15:04 MST"
	RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
	RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
	RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
	RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
	RFC3339     = "2006-01-02T15:04:05Z07:00"
	RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
	Kitchen     = "3:04PM"
	// Handy time stamps.
	Stamp      = "Jan _2 15:04:05"
	StampMilli = "Jan _2 15:04:05.000"
	StampMicro = "Jan _2 15:04:05.000000"
	StampNano  = "Jan _2 15:04:05.000000000"
	DateTime   = "2006-01-02 15:04:05"
	DateOnly   = "2006-01-02"
	TimeOnly   = "15:04:05"
)

以下是时间格式布局的一些内置常量参考,  可以注意看后面的注释，这里就是go语言中对时间格式布局元素的所有拆分和其代表的意义。

const (
	_                        = iota
	stdLongMonth             = iota + stdNeedDate  // "January"
	stdMonth                                       // "Jan"
	stdNumMonth                                    // "1"
	stdZeroMonth                                   // "01"
	stdLongWeekDay                                 // "Monday"
	stdWeekDay                                     // "Mon"
	stdDay                                         // "2"
	stdUnderDay                                    // "_2"
	stdZeroDay                                     // "02"
	stdUnderYearDay                                // "__2"
	stdZeroYearDay                                 // "002"
	stdHour                  = iota + stdNeedClock // "15"
	stdHour12                                      // "3"
	stdZeroHour12                                  // "03"
	stdMinute                                      // "4"
	stdZeroMinute                                  // "04"
	stdSecond                                      // "5"
	stdZeroSecond                                  // "05"
	stdLongYear              = iota + stdNeedDate  // "2006"
	stdYear                                        // "06"
	stdPM                    = iota + stdNeedClock // "PM"
	stdpm                                          // "pm"
	stdTZ                    = iota                // "MST"
	stdISO8601TZ                                   // "Z0700"  // prints Z for UTC
	stdISO8601SecondsTZ                            // "Z070000"
	stdISO8601ShortTZ                              // "Z07"
	stdISO8601ColonTZ                              // "Z07:00" // prints Z for UTC
	stdISO8601ColonSecondsTZ                       // "Z07:00:00"
	stdNumTZ                                       // "-0700"  // always numeric
	stdNumSecondsTz                                // "-070000"
	stdNumShortTZ                                  // "-07"    // always numeric
	stdNumColonTZ                                  // "-07:00" // always numeric
	stdNumColonSecondsTZ                           // "-07:00:00"
	stdFracSecond0                                 // ".0", ".00", ... , trailing zeros included
	stdFracSecond9                                 // ".9", ".99", ..., trailing zeros omitted

	stdNeedDate       = 1 << 8             // need month, day, year
	stdNeedClock      = 2 << 8             // need hour, minute, second
	stdArgShift       = 16                 // extra argument in high bits, above low stdArgShift
	stdSeparatorShift = 28                 // extra argument in high 4 bits for fractional second separators
	stdMask           = 1<<stdArgShift - 1 // mask out argument
)

字符串到Time时间解析函数 Parse参考：

func Parse(layout, value string) (Time, error) {
	// Optimize for RFC3339 as it accounts for over half of all representations.
	if layout == RFC3339 || layout == RFC3339Nano {
		if t, ok := parseRFC3339(value, Local); ok {
			return t, nil
		}
	}
	return parse(layout, value, UTC, Local)
}

使用示例： 

如我们有时间字符串  2024-06-27 21:09:58  要将他转换为时间对象，我们就可以使用Parse函数来实现， 因为这个时间格式time包里面已经给我们定义了常量time.DateTime 我们直接使用即可

dtstr:="2024-06-27 21:12:46"
dt,err:= time.Parse(time.DateTime,dtstr)
if err != nil {
	log.Fatalf("时间解析失败, %v", err)
}
// 这里 dt就是时间对象了，我们就可以使用他里面的所有方法了

另外一个混编的时间格式转换示例， 即在时间格式里面有英文也有数字的时间格式。

dstr := "07 Feb, 2024"
// 注意这里的时间格式"07 Feb, 2024", 是混编的 即有英文也有数字
// 我们的layout也需要混编, Jan 这个是1月的意思,对应layout中的 01, 这里的 Jan 即表示用英文来表示月份, 而02表示的是数字的日期
dt, _ = time.Parse("02 Jan, 2006", dstr)

对应这种混编的时间格式， 我们在转换的时候也需要对应的使用混编的时间布局格式元素

数字时间戳到时间对象的转换

这个有3个函数可用，根据你的数字时间的精度来选择

time.Unix(sec int64, nsec int64) time.Time   这个是纳秒数字时间到时间对象的转换函数，第一个参数 sec为数字秒， 第二个为纳秒

time.UnixMicro(usec int64) time.Time    这个是微秒数字时间到时间对象的转换函数

time.UnixMilli(msec int64) time.Time 这个是毫秒数字时间到时间对象的转换函数

时间对象到字符串的转换

这个比较简单，直接使用 Format方法即可，关键是需要掌握上面的时间布局格式的使用.

Format方法原型： func (t Time) Format(layout string) string

示例，将时间对象 dt 转换为 RFC3339 格式的字符串，即  "2006-01-02T15:04:05Z07:00"

dt:= time.Now()
str:=dt.Format(time.RFC3339)

其他

go语言的时间使用，重点就是时间格式布局，其他的时间运算很简单，官方给出了很多的使用示例和函数说明，参考官方手册即可， time package - time - Go Packages

当然，你也可以直接在命令行执行  go doc Time 查看time相关的文档。