go time.Parse的一些小知识

最新推荐文章于 2024-07-29 09:29:17 发布
最新推荐文章于 2024-07-29 09:29:17 发布
阅读量3.8k 收藏 3
点赞数 1
分类专栏： go 文章标签： go time包 源码解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26140191/article/details/98037067
版权
本文探讨了Go语言中time.Parse函数在处理时区和时间布局模板时的细节。时区问题可以通过time.ParseInLocation解决，需要注意时区定义。时间布局模板遵循特定规则，如"2006年1月2日 下午3点4分5秒 周一"，自定义布局时必须遵循这些规则。Go的内部解析方法逐个检查layout中的字符，以确定时间元素的位置。建议熟悉时间布局标准以避免解析不确定性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

之前都是写在笔记里，搬到csdn上。。。

go的time.Parse

在自己写东西时，遇到了时间转换的一些小问题。 首先是 time.Parse(layout, value), go语言提供的layout模版和我个人使用都略有差别, 转换使用很不习惯。 第二就是时区问题, 服务器的时区不一定是符合国内时区的。

时区问题

时区问题可以使用time.ParseInLocation, 但是涉及到时区定义。
查看源码定义(/time/format.go)

// 参数1还是layout
// 参数2是value
// 参数3比parse多了一个 "Location"
func ParseInLocation(layout, value string, loc *Location) (Time, error) {
	return parse(layout, value, loc, loc)
}

发现时区Location 是个结构体， 追进去看定义(/time/zoneinfo.go文件)

//go:generate env ZONEINFO=$GOROOT/lib/time/zoneinfo.zip go run genzabbrs.go -output zoneinfo_abbrs_windows.go
// 省略部分注释
type Location struct {
	name string
	zone []zone
	tx   []zoneTrans
	// 省略部分定义
}

重点是 go generate 的这一行， 是go自带的命令, 在运行时, 将后面的内容注释解析成命令执行. (还想了解更深的请自行查找)
其实需要的是 ZONEINFO=$GOROOT/lib/time/zoneinfo.zip, 也就是可以从这个路径找到对应的时区包文件。
然后在包中发现 Asia地区 关于中国的时区只有两个， 一个是Shanghai, 另一个是Chongqing。 一开始不明白的时候傻呵呵的写了 “Asia/Beijing” 然后发现并没有什么卵用。。

zoneinfo部分截图

oldTime := "2019-07-31T17:12:00Z"
location, error := time.LoadLocation("Asia/Chongqing")
time, _ := time.ParseInLocation(time.RFC3339, oldTime, location)
fmt.Println(time) // 2019-07-31 17:12:00 +0000 UTC

layout模版

time/format.go文件中包含所有的预定义 layout

const (
   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"
)

可以发现 所有的时间都指向了"2006年1月2日 下午3点4分5秒 周一"
目前听到的最多的声音是 “这是go语言的生日”。(目前我知道的最早的生日是2009-10-11)， 但从源码中可以看到一些端倪:
从time.Parse方法进入, 会进入一个内部的方法, 通过查找layout关键词, 找到了解析的方法 nextStdChunk

func parse(layout, value string, defaultLocation, local *Location) (Time, error) {
...前面省略
prefix, std, suffix := nextStdChunk(layout)
...后面省略
}

nextStdChunk方法截图
解析方法就是逐个字母遍历我们传递的layout, (类似于java中 String.charAt()),
随机打开其中的几个

case 'J': // January, Jan
   		if len(layout) >= i+3 && layout[i:i+3] == "Jan" {
   			if len(layout) >= i+7 && layout[i:i+7] == "January" {
   				return layout[0:i], stdLongMonth, layout[i+7:]
   			}
   			if !startsWithLowerCase(layout[i+3:]) {
   				return layout[0:i], stdMonth, layout[i+3:]
   			}
   		}
case '3':
   		return layout[0:i], stdHour12, layout[i+1:]
case '5':
   		return layout[0:i], stdSecond, layout[i+1:]
case 'P': // PM
   		if len(layout) >= i+2 && layout[i+1] == 'M' {
   			return layout[0:i], stdPM, layout[i+2:]
   		}
case 'Z': // Z070000, Z07:00:00, Z0700, Z07:00,
   		if len(layout) >= i+7 && layout[i:i+7] == "Z070000" {
   			return layout[0:i], stdISO8601SecondsTZ, layout[i+7:]
   		}
   		if len(layout) >= i+9 && layout[i:i+9] == "Z07:00:00" {
   			return layout[0:i], stdISO8601ColonSecondsTZ, layout[i+9:]
   		}
   		if len(layout) >= i+5 && layout[i:i+5] == "Z0700" {
   			return layout[0:i], stdISO8601TZ, layout[i+5:]
   		}
   		if len(layout) >= i+6 && layout[i:i+6] == "Z07:00" {
   			return layout[0:i], stdISO8601ColonTZ, layout[i+6:]
   		}
   		if len(layout) >= i+3 && layout[i:i+3] == "Z07" {
   			return layout[0:i], stdISO8601ShortTZ, layout[i+3:]
   		}

一切都豁然开朗, 解析其实是 将固定的字母/数字/符号 作为特殊的标志，作为特殊的位置, 在结合强力的分析, 通过截取固定的位数来判断具体属于哪种layout及每个时段的表现形式。
例如
字母 J 代表的是 月份(month)
数字 3 代表的是 小时(hour)
数字5 代表的是秒
字母P/p 代表的是 PM/pm
字母Z 代表的是具体展现形式。
and so on。

可以看到, go在内部解析是将 字母和数字分割开来，并且互相不会有影响。 但如果我们随意编写时间layout, 比如"2019-07-31 12:32:12"。结果就是比较难预测的。

所有的解析字段也在time/format.go里有常量定义:

const (
	_                        = iota
	stdLongMonth             = iota + stdNeedDate  // "January"
	stdMonth                                       // "Jan"
	stdNumMonth                                    // "1"
	stdZeroMonth                                   // "01"
	stdLongWeekDay                                 // "Monday"
	stdWeekDay                                     // "Mon"
	stdDay                                         // "2"
	stdUnderDay                                    // "_2"
	stdZeroDay                                     // "02"
	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
	stdMask      = 1<<stdArgShift - 1 // mask out argument
)

所以在自定义layout的时候 一定要遵循这个时间规范， "2006年1月2日 下午3点4分5秒 周一"
或者一个小顺口溜(来源于studygolang.com的徐大) : “1月2日3点4分5秒6年7时区” 刚好是1234567

像我个人常用的时间表示类似于 -> “2019-08-01 13:20:05”

// java写法
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
sdf.format(date);

// php写法
(new Datetime())->modify("")->format('Y-m-d H:i:s');

// go写法
oldTime := "2019-07-31T17:12:00Z"
// 当然 不用时区 直接time.Parse()也是可以的
location, error := time.LoadLocation("Asia/Chongqing")
time, _ := time.ParseInLocation(time.RFC3339, oldTime, location)
time.Format("2006-01-02 15:04:05")

总结

go的这个时间解析layout的设计还是非常巧妙的， 虽然对新手仿佛不是那么友好～ 尤其一上来这个时间戳让人有点摸不到头脑。
更多的使用例子在 /time/example_test.go文件中， 也有许多注释说明。

【golang】time.Parse 统一时区
qq_28036049的博客
03-22 2490
UTC：世界标准时间（英語：Coordinated Universal Time，法語：Temps Universel Coordonné，简称UTC）是最主要的世界時間標準 CST ：UTC+8时区名称，中国标准时间是其一，详见维基百科释义 GMT：格林尼治平均时间（Greenwich Mean Time），前世界标准时 示例： layout := "2006-01-02 15:04:05" now := time.Now().Format(layout) t1, _ := time.Parse(l
go语言学习笔记之json---Golang解析json对象时time类型解析异常的解决方法
新手小T
09-01 1304
自定义序列化和反序列化1、time类型2、解析"2006-01-02 15:04:05"格式3、解析RFC3339格式的time4、完整代码总结 1、time类型 查看官方文档 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:
go语言时间和日期的转化
weixin_45533687的博客
05-19 5053
go语言时间和日期的转化
【go】time.Parse 和time.Format
prowhite的博客
07-04 885
这时我们需要给他一个标准化模板，也就是layout，我们就根据特定的时间（2006 年 1 月 2 日 15:04:05 MST），需要的方式（7/25/2019 13:45:00），来得出layout。举个例子，例如我想要把"7/25/2019 13:45:00"转化成time的类型，这是被转化的变量，也就是value。这个layout是一个特定的时间2006 年 1 月 2 日 15:04:05 MST，用不同的方式书写，参考。实际上就是Parse的逆过程，把一个time类型转换成string类型。
golang的time.Parse()函数
热门推荐
shengzhu1的博客
03-28 3万+
golang的time包官方API：func Parse(layout, value string) (Time, error) Code:// See the example for time.Format for a thorough description of how // to define the layout string to parse a time.Time value; Par
Golang时间包的“坑” time.Parse
wxs0607
02-27 9087
开发过程中，无意发现的bug 首先看一段代码： func main() { st := "2019-11-21 11:59:01" fmt.Printf("%s\n", st) t, _ := time.Parse("2006-01-02 15:04:05", st) fmt.Println(t.Unix()) tt := time.Unix(t.Unix(), 0) fmt.P...
Golang开发的dateparse任务：俄语到time.Time的转换
1. Golang开发：Golang，通常被称为Go，是一种编译型、静态类型语言，由Google开发。它的设计初衷是为了简化编程工作，其语法简洁，同时支持并发和垃圾回收机制。Golang常用于构建系统软件、网络服务器以及高性能...
go依赖包golang.org/x下的所有源码
05-04
在Go语言的生态系统中，`golang.org/x`是一个非常重要的模块集合，它包含了Go官方维护但未包含在标准库中的各种扩展包。这些包涵盖了网络、文本处理、加密算法等多个领域，为开发者提供了丰富的功能支持。由于网络...
Go-Golang模板语言和FuncMap功能的简单演示
08-13
在Golang中，模板语言是用于动态生成文本输出的强大工具，尤其在Web开发中非常常见。这个"Go-Golang模板语言和FuncMap功能的简单演示"可能是为了介绍如何使用Go...熟悉并掌握这些知识对于进行Go语言的Web开发至关重要。
gorm 遇坑总结
耕云者~
10-26 1226
gorm debug 出来的语句可以正常执行，但是程序就是有问题？？
golang圣经
03-01
golang 圣经学习golang可以参考下 Go（又称Golang）是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。
Go 的时间操作
m0_54644067的博客
05-14 4208
Go 语言中可以通过 time.Time 类型的 Format()函数对时间进行格式化，该函数的第一个参数是格式化的模板，模板里面的时间必须是 2006-01-02 15:04:05 这个时间，这个时间是固定的，不然就会出错，第二个参数是要格式化的时间。time.Timer 类型表示单次时间事件。time.Duration 是 time 包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。time.Duration 是 time 包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。
go语言中的时间转化
小熊提伯斯的博客
07-18 1018
package main import ( "fmt" "time" ) func main() { //获取当前时间 now := time.Now() //时间转化为string timeStr := now.Format("2006-01-02 15:04:05") fmt.Println("日期类型当前时间: ", now) fmt.Println("字符串类型当前时间: ", timeStr) //string转化为时间 date, _ := time.Parse("2.
golang 读取redis时间 及time.Parse() 格式
仅做个人笔记
10-12 1371
redis 存时间戳 最方便 如果要存时间的话： hset的时候有两种: 一、time类型的.String() HSet(key, "replyAt", time.Now().String()) 2019-10-14 10:28:34.184535257 +0800 CST m=+152806.843317207 二、time类型的Marshal先转json字符串，再Unma...
go语言基础之time时间处理
liu289747235的专栏
01-28 1269
时区（Time Zone）是根据世界各国家与地区不同的经度而划分的时间定义，全球共分为24个时区。判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。函数能够将一个时间对象格式化输出为指定布局的文本表示形式，需要注意的是 Go 语言中时间格式化的布局不是常见的。函数获取当前的时间对象，然后从时间对象中可以获取到年、月、日、时、分、秒等信息。time 包还提供了一系列将 int64 类型的时间戳转换为时间对象的方法。包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。
golang的时区和神奇的time.Parse
码农高端会所
07-15 2163
转自： https://www.jianshu.com/p/f809b06144f7 时区 先写一段测试代码： const TIME_LAYOUT = "2006-01-02 15:04:05" func parseWithLocation(name string, timeStr string) (time.Time, error) { locationName := name if l, err := time.LoadLocation(locationName); err != ni
Golang学习日志 ━━ 当前时间time.Now()和自定义时间time.Parse()的差值now.Sub(parse)注意点
暂时先用这个名字
02-06 4091
没什么特别的地方，主要是time.Now()获得的时间是东八区时间，而time.Parse()得到的时间是utc时间，二者直接比较会出错，所以要先转换一下，如下示例： //获取并显示当前时间 fmt.Println("now()时间:", time.Now(), "显示的是东八区时间") //解析并显示自定义时间 pt, _ := time.Parse("2006-01-02 15:04:...
Go 之 time 模块相应函数及示例
Looking的博客
10-09 488
Go 之 time 模块相应函数及示例
Golang 问题汇总
最新发布
tabianY的专栏
07-29 305
例：time.ParseInLocation("2006-01-02 15:04:05", "2024-07-29 00:00:00", time.Local)time.Parse输出是UTC时间，比预期的多了8个小时。解决：使用time.ParseInLocation，指定时区。① time.Parse时区问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值