一文搞懂go时间库time的使用

已于 2023-08-25 16:23:00 修改
阅读量1.1k 收藏
点赞数
分类专栏： golang 文章标签： golang 开发语言 后端
于 2023-08-17 18:54:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keenw/article/details/132345789
版权

作者：程序员CKeen
博客：http://ckeen.cn

长期坚持做有价值的事！积累沉淀，持续成长，升维思考！希望把编码作为长期兴趣爱好😄

目录

时间和日期是我们日常开发中经常会用到的功能。Go 语言中的 time 包提供了处理时间和日期的功能。它包含了许多函数和类型，用于获取当前时间、格式化时间、解析字符串为时间、进行时间计算等操作。

1. 时间类型

go中使用time.Time类型来定义时间类型。 可以通过Now方法获取当前时间的对象

// 获取当前时间
time1 := time.Now()
fmt.Printf("time now:%+v,  string:%s\n", time1, time1.String())

获取到时间对象后，我们就能根据对象获取具体的日期、时间及星期等信息

fmt.Printf("Time: %d-%d-%d %d:%d:%d %s\n", time1.Year(),time1.Month(),time1.Day(),time1.Hour(),
		time1.Minute(),time1.Second(), time1.Weekday().String())
// 打印结果：Time:2023-7-11 14:47:23 Tuesday

fmt.Printf("days:%d\n", time1.YearDay())
// 打印结果：days:192, 返回今天在1年中的天数

除了直接获取当前时间，time库还提供了一个time.Date的方式，根据日期、时间及区域来创建Time实例，如下：

time11 := time.Date(2023,7,10,15,10,11,999000111,time.Local)
// 依次传入的参数为： 年、月、日、时、分、秒、纳秒，时间Location
fmt.Printf("Time:%d-%d-%d %d:%d:%d %s\n", time11.Year(),
time11.Month(),time11.Day(),time11.Hour(),
time11.Minute(),time11.Second(), time11.Weekday().String())

// 打印结果：Time:2023-7-10 15:10:11 Monday

2. 时间戳

时间戳是自1970年1月1日（08:00:00GMT）至当前时间的总毫秒数。它也被称为Unix时间戳（UnixTimestamp）。

时间戳一般有精确到不同秒数的时间戳，比如精确到秒、毫秒、微秒和纳秒等，不同精度的长度也不一样（1秒=1000毫秒=1000000微秒=1000000000纳秒）。

我们来具体看下获取时间戳的方式

time1 := time.Now()
fmt.Printf("Timestamp: 秒unix:%d,纳秒unixNano:%d,微秒unixMicro:%d,毫秒unixMilli:%d\n", time1.Unix(), time1.UnixNano(), time1.UnixMicro(),time1.UnixMilli())

// 打印结果：Timestamp: 秒unix:1689060513,纳秒unixNano:1689060513736593000,微秒unixMicro:1689060513736593,毫秒unixMilli:1689060513736

从打印结果可以看到不同精度下的时间戳。除了可以从时间Time对象从很方便的获取不同的时间戳对象，同时我们也可以通过时间戳来构建Time对象实例，go的time库提供了如下几个函数来构建Time实例：

func Unix(sec int64, nsec int64) Time  
func UnixMilli(msec int64) Time
func UnixMicro(usec int64) Time

我们来具体看下操作的方法

// 首先我们获取2023-07-11 00：00：00 时间戳为：1689004800

seconds_time := time.Unix(int64(1689004800),int64(9999999999))
fmt.Printf("seconds time:%s\n",seconds_time.String())
// 打印结果： seconds time:2023-07-11 00:00:09.999999999 +0800 CST

milli_seconds_time := time.UnixMilli(int64(1689004800999))
fmt.Printf("milli secords time:%s\n", milli_seconds_time.String())
// 打印结果：milli secords time:2023-07-11 00:00:00.999 +0800 CST

micro_seconds_time := time.UnixMicro(int64(1689004800999999))
fmt.Printf("micro seconds time:%s\n", micro_seconds_time.String())
// 打印结果：micro seconds time:2023-07-11 00:00:00.999999 +0800 CST
  • 第一个方法Unix(sec int64, nsec int64)通过传入时间戳秒和纳秒两个参数来构建时间对象，可以看到他打印的除了包含日期、时间外，最后还有个9位纳秒的数值：999999999
  • 第二个方法UnixMilli(msec int64)通过传入微秒的时间戳来构建时间对象，可以看到他打印的除了包含日期、时间外，最后显示的值为3位的微秒数值：999
  • 第三个方法UnixMicro(usec int64)通过传入毫秒的时间戳来构建时间对象，可以看到他打印的除了包含日期、时间外，最后显示的值为6位的毫秒数值：999999

3. 时间间隔Duration

time.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。time.Duration表示一段时间间隔，可表示的最长时间段大约290年。

time包中定义的一些常量来表示具体的时间单位到纳秒换算

const (
	Nanosecond  Duration = 1
	Microsecond          = 1000 * Nanosecond
	Millisecond          = 1000 * Microsecond
	Second               = 1000 * Millisecond
	Minute               = 60 * Second
	Hour                 = 60 * Minute
)

下面我们具体看下Duration的创建和对时间的换算

// 创建Duration实例
duration := time.Duration(1000 * time.Second)  
fmt.Printf("duration:%+v, int64:%d\n", duration, duration.Nanoseconds())
// 打印结果：duration:16m40s, int64:1000000000000

// 将字符串转换为Duration
duration1, err := time.ParseDuration("16m40s")
if err == nil {
  fmt.Printf("duration:%+v, int64:%d\n", duration1, duration1.Nanoseconds())
}
// 打印结果：duration:16m40s, int64:1000000000000

// duration到小时，分，秒的转换
fmt.Printf("hour:%f,minutes:%f, seconds:%f\n",duration.Hours(), duration.Minutes(), duration.Seconds())
// 打印结果： hour:0.277778,minutes:16.666667, seconds:1000.000000

除了使用Duration对间隔时间的换算，还能和Time的时间对象进行运算，在后面的“时间操作”部分我们将详细的介绍

4. 时间操作

4.1 时间（Time）+ 时间间隔（Duration）的计算的函数Add，函数如下：

  func (t Time) Add(d Duration) Time

实际操作的例子，比如我们计算当前时间72小时前的时间

 time72hour := time.Now().Add( -72 * time.Hour )
 fmt.Printf(" before 72 hours time:%s\n", time72hour)
 
 // 打印结果： before 72 hours time:2023-07-08 22:01:11.023477 +0800 CST m=-259199.999698469

4.2 时间（Time） + 日期间隔（Year,Month, Day）的计算的函数AddDate，函数如下：

func (t Time) AddDate(years int, months int, days int) Time

该方法平时我们在时间计算上用的更多，比如我们计算1年前，或者下个月的今天等

now := time.Now()

// 计算1年前的今天
time1year := now.AddDate(-1,0, 0)
fmt.Printf(" before one year time:%s\n", time1year)
// 打印结果： before one year time:2022-07-11 22:08:00.335251 +0800 CST

// 计算下个月的今天
time1month := now.AddDate(0, 1,0)
fmt.Printf(" after one month time:%s\n", time1month)
// 打印结果：after one month time:2023-08-11 22:08:00.335251 +0800 CST

4.3 计算两个时间直接的差值函数Sub，函数如下：

func (t Time) Sub(u Time) Duration

使用示例：

start := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
end := time.Date(2023, 7, 11, 12, 0, 0, 0, time.UTC)

sub := end.Sub(start)
fmt.Printf("sub = %v\n", sub)
// sub = 4596h0m0s

4.4 时间的比较，提供一下三个函数

// 比较两个时间是否相等，即使他们的时区不同，也可以相等
func (t Time) Equal(u Time) bool
// 判断当前实例时间是否在某个时间之前
func (t Time) Before(u Time) bool
// 判断当前实例时间是否在某个时间之后
func (t Time) After(u Time) bool

​ 有了以上这些对时间操作的函数，我们可以很方便的实现一些时间计算的求解，比如类似获取上一个月的第一天和最后一天等需求，实现方式如下：

now := time.Now()
// 计算上个月的第一天
lastMonthFirstDay := now.AddDate(0, -1,-now.Day() + 1)
// 计算上个月的最后一天
lastMonthLastDay := now.AddDate(0, 0, -now.Day())
fmt.Println(lastMonthFirstDay)
fmt.Println(lastMonthLastDay)

//打印结果：2023-06-01 22:31:41.323683 +0800 CST
//打印结果：2023-06-30 22:31:41.323683 +0800 CST

5. 时间格式化

在的其他的语言中我们一般以"yyyy-MM-dd HH:mm:ss"的之类的格式，来对时间进行字符串的格式化，而go中时间格式化又是怎么样的呢？ 下面我们来看个实例：

time.Now().Format("2006-01-02 15:04:05")

这格式化的方法看起来是不是有点奇怪，我们查看go的时间time包，可以看到时间格式化的Layout参数：

Layout      = "01/02 03:04:05PM '06 -0700"

这个表示用英文的时间表达形式，表示1月2号， 下午3点4分过5秒，06年的07时区，所以连起来就是01 02 03 04 05 06 07。其中下午3点，在24小时制里面是15点，所以使用24小时制格式化的时候使用15点。

time包提供了Format函数将Time格式化为字符串，同时也提供了将时间字符串转为Time实例的函数，函数如下：

func Parse(layout, value string) (Time, error)
func ParseInLocation(layout, value string, loc *Location) (Time, error)

这两个方法带的参数不同，那么他们有啥区别的，首先我们实际操作看一下：

timeParse,err := time.Parse(timerFormat,"2023-07-10 10:10:10")
if err == nil {
	fmt.Printf("time string:%s\n", timeParse)
}
// 	打印结果：time string:2023-07-10 10:10:10 +0000 UTC


timeParseLocation,err1 := time.ParseInLocation(timerFormat,"2023-07-10 10:10:10",time.Local)
if err1 == nil {
	fmt.Printf("time string:%s\n", timeParseLocation.String())
}
// 打印结果：time string:2023-07-10 10:10:10 +0800 CST

从实例结果可以看出来，他们时间都是一样的，但是时区是不一样的， Parse方法没有穿Location参数，它使用的是默认的UTC时区，而第二方法我传入的time.Local的Location参数，它使用的是我当前时区东8区的时区。那么时区对这个时间有没有影响呢，我们从下面的例子中可以得出结论：

// timeParse和timeParseLocation是上面例子中的变量

fmt.Println(timeParse.Equal(timeParseLocation))
fmt.Println(timeParse.After(timeParseLocation))
fmt.Println(timeParse.Sub(timeParseLocation))

// 打印结果：
// false
// true
// 8h0m0s

根据打印的结果我们可以看到，UTC的时间比当前东八区的时间要晚，并且晚了8小时。所以我们在使用字符串转换的时候，需要注意时区的问题。

6. 时间Time中的Location

Location将时间映射到当时正在使用的区域。通常，Location表示在一个地理区域中使用的时间偏移量的集合

在time.Time的结构中，有一个就是Location结构的指针用来定义当前时间的时区信息，time.Time结构定义：

type Time struct {
	wall uint64
	ext  int64
	loc *Location
}

time库中预定义的time.UTC定义的UTC时区Locaiton，还有time.Local定义的本地时区Locatoin。除了time预定外的两个时区，time提供了LoadLocation函数来获取*Location实例，示例如下：

loc,_ := time.LoadLocation("UTC")
loc1,_ := time.LoadLocation("Asia/Shanghai")
loc2,_ := time.LoadLocation("Europe/London")
loc3,_ := time.LoadLocation("Asia/Tokyo")
程序猿CKeen
关注
专栏目录
腾讯trpc-go教程——一文搞懂trpc框架
itcyy的博客
12-06 2556
最近腾讯开源了trpc框架，小编心血来潮就去研究了以下，现在将研究结果分享给大家。
一文教你搞懂Go中栈操作
j简说Linux的博客
11-16 1180
在 32 位模式下，它总是 4GB 内存地址空间，内存分配是分配虚拟内存给进程，当进程真正访问某一虚拟内存地址时，操作系统通过触发缺页中断，在物理内存上分配一段相应的空间再与之建立映射关系，这样进程访问的虚拟内存地址，会被自动转换变成有效物理内存地址，便可以进行数据的存储与访问了。会发生在 GC 的时候。当执行栈扩容时，会在内存空间中分配更大的栈内存空间，然后将旧栈中的所有内容复制到新栈中，并修改指向旧栈对应变量的指针重新指向新栈，最后销毁并回收旧栈的内存空间，从而实现栈的动态扩容。
timefmt-go:Golang的高效时间格式化库（strftime，strptime）
05-15
timefmt-go Golang的高效时间格式化库（strftime，strptime） 这是用于格式化和解析日期时间字符串的Go语言包。 package main import ( "fmt" "log" "github.com/itchyny/timefmt-go" ) func main () { t , err := timefmt . Parse ( "2020/07/24 09:07:29" , "%Y/%m/%d %H:%M:%S" ) if err != nil { log . Fatal ( err ) } fmt . Println ( t ) // 2020-07-24 09:07:29 +0000 UTC str := timefmt . Format ( t , "%Y/%m/%d %H:%M:%S" ) fmt . Println
go语言time库
jakelihua
04-12 334
time包是Go语言标准库中的一个包，它提供了时间处理相关函数。time包中定义了一个名为Time的类型，表示一个日期和时间值。time.Now()：获取当前时间。time.Parse(layout, value string)：根据指定的格式解析时间字符串，并返回对应的Time类型。time.Location)：根据指定的格式和时区解析时间字符串，并返回对应的Time类型。time.Time.Format(layout string)：将时间格式化为指定的字符串格式。
【Golang】Go 语言中的 time 包详解：全面掌握时间处理与应用
最新发布
Linke的博客
10-11 1798
在 Go 语言中，time包提供了强大的时间处理功能，适用于各种场景：获取当前时间、格式化和解析时间、计算时间间隔、设置定时器、处理超时等。在开发过程中，熟练掌握time包能够帮助我们轻松处理时间相关的操作，尤其是定时任务、超时控制等非常常见的功能。
Go 标准库介绍二: time
ironxu的专栏
03-08 966
发表一篇介绍Go 标准库 time 常用导出函数，结构体及其方法的笔记博客。
一文了解 Go time 包的时间常用操作
cmy_top的博客
12-03 913
本文将会对 Go time 包里面的常用函数和方法如获取当前时间、时间格式化、获取具体时间格式的值如年月日等进行介绍。
go语言常用标准库(Time)
编程技术， 日益精进
09-18 387
时间和日期是我们编程中经常会用到的，本文主要介绍了Go语言内置的time包的基本用法。
一文搞懂JAVA与Go垃圾回收
tomfyyds的博客
11-30 469
现代高级编程语言管理内存的方式分自动和手动两种。手动管理内存的典型代表是C和C++，编写代码过程中需要主动申请或者释放内存；而 PHP、Java 和 Go等语言使用自动的内存管理系统，由内存分配器和垃圾收集器来代为分配和回收内存，其中垃圾收集器就是我们常说的GC。本文中，笔者将从原理出发，介绍Java和Golang垃圾回收算法，并从原理上对他们做一个对比。 Java垃圾回收 垃圾回收区域及划分 在介绍Java垃圾回收之前，我们需要了解Java的垃圾主要存在于哪个区域。JVM内存运行时.
python把日期转换为时间索引_8例 | 一文搞懂python日期时间处理
weixin_39580042的博客
12-18 752
Hello大家好，欢迎来到【统计GO】，本公众号内容主要针对数据分析的爱好者，不定期分享一些好用的数据分析工具和机器学习资料，以及一些求职必备技能，帮助大家花更少的时间学更多的知识。本期为大家推荐的是Python语言中datetime模块中datetime类的各种方法和属性，并提供代码案例，方便大家使用时查找。如果本期内容对您有所帮助，记得及时关注导入datetime类from datetime ...
Go语言time库，时间和日期相关的操作方法
汉阳Hann's Home
08-01 5347
Go语言time库用于处理时间、日期和时区的核心库。在实际开发中，常常需要与时间打交道，例如记录日志、处理时间差、计算时间间隔等等。
go语言time包的简单使用
Xjy_1996的博客
08-23 224
time time.Time 时间点 time.Time 代表一个纳秒精度的时间点 每个时间点都具有时区信息，Local、UTC和In方法返回一个指定时区（指向同一个时间点）的Time。修改时区信息只是会改变其表示，不会修改被表示的时间点。 var t time.Time t = time.Now() // 获取当前时间 tLocation := t.Location() // 获取当前时区...
Go语言_时间篇
weixin_34267123的博客
06-12 119
哎，先发下牢骚，Go文档还是太弱了，特别是标准库中的文档说明，很多函数几乎就一句话过了。这点确实该向Microsoft的MSDN好好学学。   Go的time包是标准库中的包之一 不用说，几乎是开发必须用到的包之一。time包的说明文档在： http://golang.org/pkg/time/   先注意下Overview中的一句话： The calendrical calcula...
Go语言时间库golang-module/carbon
YIYIYI
06-09 2303
Go语言时间库golang-module/carbon
golang包time用法详解
youmangu的专栏
07-23 2313
转载：https://blog.csdn.net/wschq/article/details/80114036 在我们编程过程中，经常会用到与时间相关的各种务需求，下面来介绍 golang 中有关时间的一些基本用法,我们从 time 的几种 type 来开始介绍。 时间可分为时间点与时间段，golang 也不例外，提供了以下两种基础类型 - 时间点(Time) - 时间段(Duration) 除此之外 golang 也提供了以下类型，做一些特定的业务 - 时区(Location) - Ticker -
go time
仅做个人笔记
10-14 420
// 每隔一段时间同步文章统计信息、推荐文章信息、评论统计信息的变动到mysql func initArticleActionSync() { ticker := time.NewTicker(time.Duration(config.GlobalConfig.Sync.ArticleAction) * time.Second) recommend := time.NewTicker(tim...
一文搞懂如何实现 Go 超时控制
我心飞翔
03-29 409
为什么需要超时控制？ 请求时间过长，用户侧可能已经离开本页面了，服务端还在消耗资源处理，得到的结果没有意义 过长时间的服务端处理会占用过多资源，导致并发能力下降，甚至出现不可用事故 Go 超时控制必要性 Go 正常都是用来写后端服务的，一般一个请求是由多个串行或并行的子任务来完成的，每个子任务可能是另外的内部请求，那么当这个请求超时的时候，我们就需要快速返回，释放占用的资源，比如goroutine，文件描述符等。 服务端常见的超时控制 进程内的逻辑处理 读写客户端请求，比如HTTP或者RPC请求 调
GO语言-time
李俊的博客
01-29 402
一、time包 time包提供了时间的显示和测量用的函数。日历的计算采用的是公历。 1.1 时间类型 time.Time类型表示时间。我们可以通过time.Now()函数获取当前的时间对象，然后获取时间对象的年月日时分秒等信息。示例代码如下： func timeDemo() { now := time.Now() //获取当前时间 fmt.Printf("current time:%...
Go语言标准库Time
专注基础架构领域
11-04 499
time包提供了时间的显示和测量用的函数。日历的计算采用的是公历。 type Duration int64 const ( Nanosecond Duration = 1 Microsecond = 1000 * Nanosecond Millisecond = 1000 * Microsecond Second = 1000 * Millisecond Minute ...
[Go关于时间] time库/扩展now库
jziwjxjd的博客
03-24 766
参考自liwenzhou 文章目录Time库Time对象时区概念Unix Time时间间隔,加减法定时器格式化时间从字符串中解析时间jinzhu/now库优化time.Parse Time库 Time对象 Go语言中使用time.Time类表示时间 可以由这个对象获取到年、月、日、时、分、秒等信息 func timeDemo() { now := time.Now() // 获取当前时间 fmt.Printf("current time:%v\n", now) year := now.Year()
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿CKeen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值