go中的时间处理过程
更新时间：2025年07月03日 14:16:07 作者：alden_ygq
这篇文章主要介绍了go中的时间处理过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
1 获取当前时间
currentTime:=time.Now() //获取当前时间，类型是Go的时间类型Time t1:=time.Now().Year() //年 t2:=time.Now().Month() //月 t3:=time.Now().Day() //日 t4:=time.Now().Hour() //小时 t5:=time.Now().Minute() //分钟 t6:=time.Now().Second() //秒 t7:=time.Now().Nanosecond() //纳秒 //如果获取UTC时间，则可以使用time.UTCcurrentTimeData:=time.Date(t1,t2,t3,t4,t5,t6,t7,time.Local) //获取当前时间，返回当前时间Time fmt.Println(currentTime) //打印结果：2017-04-11 12:52:52.794351777 +0800 CST fmt.Println(t1,t2,t3,t4,t5,t6) //打印结果：2017 April 11 12 52 52 fmt.Println(currentTimeData) //打印结果：2017-04-11 12:52:52.794411287 +0800 CST
time.Now()和Date()方法都可以获取当前时间，time.Now()用起来比较简单，但是Date()可以获取不同的精确值，如time.Date(t1,t2,t3,t4,t5,t6,0,time.Local)将毫秒省略，精确到秒，结果为：2017-04-11 12:52:52 +0800 CST。
2 获取当前时间戳
timeUnix:=time.Now().Unix() //单位s,打印结果:1491888244 timeUnixNano:=time.Now().UnixNano() //单位纳秒,打印结果：1491888244752784461
3 获取当前时间的字符串格式
timeStr:=time.Now().Format("2006-01-02 15:04:05") //当前时间的字符串，2006-01-02 15:04:05据说是golang的诞生时间，固定写法
fmt.Println(timeStr) //打印结果：2017-04-11 13:24:044 相互转化
4.1 时间戳转时间字符串 (int64 > string)
timeUnix:=time.Now().Unix() //已知的时间戳
formatTimeStr:=time.Unix(timeUnix,0).Format("2006-01-02 15:04:05")
fmt.Println(formatTimeStr) //打印结果：2017-04-11 13:30:394.2 时间字符串转时间(string > Time)
formatTimeStr="2017-04-11 13:33:37"
formatTime,err:=time.Parse("2006-01-02 15:04:05",formatTimeStr)
if err==nil{
fmt.Println(formatTime) //打印结果：2017-04-11 13:33:37 +0000 UTC
}
4.3 时间字符串转时间戳 (string > int64)
formatTimeStr="2017-04-11 13:33:37"
formatTime,err:=time.Parse("2006-01-02 15:04:05",formatTimeStr)
utime := formatTime.Unix()
if err == nil{
fmt.Println(utime) //打印结果：2017-04-11 13:33:37 +0000 UTC
}5 时间计算
5.1 获取今天0点0时0分的时间戳
currentTime := time.Now()
startTime := time.Date(currentTime.Year(), currentTime.Month(), currentTime.Day(), 0, 0, 0, 0, currentTime.Location())
fmt.Println(startTime)
fmt.Println(startTime.Format("2006/01/02 15:04:05")) 5.2 获取今天23:59:59秒的时间戳
currentTime := time.Now()
endTime := time.Date(currentTime.Year(), currentTime.Month(), currentTime.Day(), 23, 59, 59, 0, currentTime.Location())
fmt.Println(endTime)
fmt.Println(endTime.Format("2006/01/02 15:04:05")) 5.3 获取1分钟之前的时间
m, _ := time.ParseDuration("-1m")
result := currentTime.Add(m)
fmt.Println(result)
fmt.Println(result.Format("2006/01/02 15:04:05"))5.4 获取1小时之前的时间
m, _ := time.ParseDuration("-1h")
result := currentTime.Add(m)
fmt.Println(result)
fmt.Println(result.Format("2006/01/02 15:04:05")) 5.5 获取1分钟之后的时间
m, _ := time.ParseDuration("1m")
result := currentTime.Add(m)
fmt.Println(result)
fmt.Println(result.Format("2006/01/02 15:04:05")) 5.6 获取1小时之后的时间
m, _ := time.ParseDuration("1h")
result := currentTime.Add(m)
fmt.Println(result)
fmt.Println(result.Format("2006/01/02 15:04:05")) 5.7 计算两个时间戳之间的时间
afterTime, _ := time.ParseDuration("1h")
result := currentTime.Add(afterTime)
beforeTime, _ := time.ParseDuration("-1h")
result2 := currentTime.Add(beforeTime)
m := result.Sub(result2)
fmt.Printf("%v 分钟 \n", m.Minutes())
h := result.Sub(result2)
fmt.Printf("%v小时 \n", h.Hours())
d := result.Sub(result2)
fmt.Printf("%v 天\n", d.Hours()/24)
5.8 判断一个时间是否在一个时间之后
stringTime, _ := time.Parse("2006-01-02 15:04:05", "2019-12-12 12:00:00")
beforeOrAfter := stringTime.After(time.Now())
if true == beforeOrAfter {
fmt.Println("2019-12-12 12:00:00在当前时间之后!")
} else {
fmt.Println("2019-12-12 12:00:00在当前时间之前!")
} 5.9 判断一个时间相比另外一个时间过去了多久
startTime := time.Now()
time.Sleep(time.Second * 5)
fmt.Println("离现在过去了：", time.Since(startTime)) 6 time.Sleep睡眠指定时间(小时级到纳秒级)
golang的休眠可以使用time包中的Sleep函数实现，本节主要介绍关于go time.Sleep睡眠指定时间(小时级到纳秒级）相关实现。
6.1 单位
time.sleep单位为:1ns (纳秒)
6.2 转换单位
- 1纳秒 =1000皮秒
- 1纳秒 =0.001 微秒
- 1纳秒 =0.000 001毫秒
- 1纳秒 =0.000 000 001秒
go用来指定睡眠时间的函数为time.Sleep，接口为：
// Sleep pauses the current goroutine for at least the duration d. // A negative or zero duration causes Sleep to return immediately. func Sleep(d Duration)
传入的为一个Duration，所以如果想睡眠5s钟，不能直接写 time.Sleep(5) ，而应该写time.Sleep(5 * time.Second)
其中time.Second就是一个Duration类型，表示1s的时间间隔，乘系数5就得到5s的时间间隔。
除了time.Second外，go还提供了不同的时间单位：
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)其中，
- Nanosecond表示1纳秒的时间间隔
- Microsecond表示1微妙的时间间隔
- Millisecond表示1毫秒的时间间隔
- Second表示1秒的时间间隔
- Minute表示1分钟的时间间隔
- Hour表示1小时的时间间隔
想要睡眠的时间可以使用以上的常量自由组合，比如睡眠1小时10分5秒：
time.Sleep(1*time.Hour + 10*time.Minute + 5*time.Second)
7 耗时统计
7.1 常规写法
package main
import (
"fmt"
"time"
)
func main() {
bT := time.Now() // 开始时间
time.Sleep(5*time.Second)
eT := time.Since(bT) // 从开始到当前所消耗的时间
fmt.Println("Run time: ", eT)
}运行结果：
Run time: 5.001531s
7.2 原始方式
在函数起始位置计算当前时间，在函数结束位置算出耗时。
package main
import (
"fmt"
"time"
)
func sum(n int) int {
var total int
startT := time.Now()//计算当前时间 total := 0
for i:=1; i <= n; i++ {
total += i
}
tc := time.Since(startT)//计算耗时
fmt.Printf("time cost = %v\n", tc)
return total
}
func main() {
count := sum(100)
fmt.Printf("count = %v\n", count)
}运行结果：
time cost = 250ns count = 5050
7.3 简洁方法
计算当前时间与计算耗时放在两处，难免显得丑陋，且不易阅读。如果有多个函数需要统计耗时，那么多处书写重复的两行代码会造成代码冗余。由于 Golang 提供了函数延时执行的功能，借助 defer ，可以通过函数封装的方式来避免代码冗余。
package main
import (
"fmt"
"time"
)
//耗时统计函数
func timeCost(start time.Time){
tc:=time.Since(start)
fmt.Printf("time cost = %v\n", tc)
}
func sum(n int) int {
defer timeCost(time.Now())
total := 0
for i:=1; i <= n; i++ {
total += i
}
return total
}
func main() {
count := sum(100)
fmt.Printf("count = %v\n", count)
}运行结果：
time cost = 333ns count = 5050
通过输出可以看到sum()耗时增加了，因为增加了一次timeCost()函数调用。不过相比于函数封装带来的便利与代码美观，新增的耗时是微不足道可以接受的。
7.4 优雅方法
每次调用耗时统计函数timeCost()都需要传入time.Now()，重复书写time.Now()无疑造成了代码冗余。
在上面的基础上，进行进一步的封装，实现如下：
package main
import (
"fmt"
"time"
)
//耗时统计函数
func timeCost() func() {
start := time.Now()
return func() {
tc:=time.Since(start)
fmt.Printf("time cost = %v\n", tc)
}
}
func sum(n int) int {
defer timeCost()()//注意，是对 timeCost()返回的函数进行调用，因此需要加两对小括号
total := 0
for i:=1; i <= n; i++ {
total += i
}
return total
}
func main() {
count := sum(100)
fmt.Printf("count = %v\n", count)
}运行结果：
time cost = 1.204µs count = 5050
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。
相关文章
本文主要介绍了Go语言Gin框架中使用MySQL数据库的三种方式,通过三种方式实现增删改查的操作,具有一定的参考价值,感兴趣的可以了解一下2023-11-11
这篇文章主要为大家介绍了从生成CRD到编写自定义控制器的教程示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-05-05
这篇文章主要为大家介绍了使用gorm.Scopes函数实现复用查询逻辑示例,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪2023-12-12
本文主要介绍了Go手写数据库ZiyiDB的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧2025-05-05
Go的切片类型为处理同类型数据序列提供一个方便而高效的方式，下面这篇文章就来给大家介绍了关于Golang中切片的用法与本质的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下2018-07-07
Go语言结合gorm实现读取PostgreSQL的json数据类型
使用gorm读取PostgreSQL中json/jsonb类型数据是一个常见的操作,本文介绍几种方法,适用于几类不同的场景,感兴趣的小伙伴可以跟随小编一起学习一下2025-10-10
这篇文章主要给大家介绍了关于golang小游戏开发实战之飞翔的小鸟的相关资料,,本文可以带你你从零开始,一步一步的开发出这款小游戏,文中通过代码介绍的非常详细,需要的朋友可以参考下2024-03-03
protobuf是Google公司提出的一种轻便高效的结构化数据存储格式,常用于结构化数据的序列化,具有语言无关、平台无关、可扩展性特性,常用于通讯协议、服务端数据交换场景,下面我们就来看看golang中protobuf的具体使用吧2023-10-10
本文介绍了如何使用Go语言配置Sentinel的动态数据源,并通过本地文件和Nacos两种方式实现动态配置,通过这种方式,可以灵活地管理和更新限流规则,提升系统的稳定性和响应速度,感兴趣的朋友跟随小编一起看看吧2025-01-01
一文带你掌握Go语言I/O操作中的io.Reader和io.Writer
在 Go 语言中,io.Reader 和 io.Writer 是两个非常重要的接口,它们在许多标准库中都扮演着关键角色,下面就跟随小编一起学习一下它们的使用吧2025-01-01
最新评论