go中的时间处理过程

2025-07-03 17:50
文章标签 go 时间 处理过程

本文主要是介绍go中的时间处理过程，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《go中的时间处理过程》：本文主要介绍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:04

4 相互转化

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:39

4.2 时间字符串转时间(string >  Tjavascriptime)

formatTimeStr="20China编程17-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)
fmtwww.chinasem.cn.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()返回的函数进行调用，因此需要加两对小括号php
        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.204s
count = 5050

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编javascript程China编程(www.chinasem.cn)。

这篇关于go中的时间处理过程的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1155293。

相关文章

从基础到高级详解Go语言中错误处理的实践指南

从基础到高级详解Go语言中错误处理的实践指南

《从基础到高级详解Go语言中错误处理的实践指南》Go语言采用了一种独特而明确的错误处理哲学,与其他主流编程语言形成鲜明对比,本文将为大家详细介绍Go语言中错误处理详细方法,希望对大家有所帮助... 目录1 Go 错误处理哲学与核心机制1.1 错误接口设计1.2 错误与异常的区别2 错误创建与检查2.1 基础
阅读更多...
Go语言中json操作的实现

Go语言中json操作的实现

《Go语言中json操作的实现》本文主要介绍了Go语言中的json操作的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录 一、jsOChina编程N 与 Go 类型对应关系️ 二、基本操作：编码与解码 三、结构体标签（Struc
阅读更多...
java时区时间转为UTC的代码示例和详细解释

java时区时间转为UTC的代码示例和详细解释

《java时区时间转为UTC的代码示例和详细解释》作为一名经验丰富的开发者,我经常被问到如何将Java中的时间转换为UTC时间,：本文主要介绍java时区时间转为UTC的代码示例和详细解释,文中通... 目录前言步骤一：导入必要的Java包步骤二：获取指定时区的时间步骤三：将指定时区的时间转换为UTC时间步
阅读更多...
使用Go调用第三方API的方法详解

使用Go调用第三方API的方法详解

《使用Go调用第三方API的方法详解》在现代应用开发中,调用第三方API是非常常见的场景,比如获取天气预报、翻译文本、发送短信等,Go作为一门高效并发的编程语言,拥有强大的标准库和丰富的第三方库,可以... 目录引言一、准备工作二、案例1：调用天气查询 API1. 注册并获取 API Key2. 代码实现3
阅读更多...
基于Go语言开发一个 IP 归属地查询接口工具

基于Go语言开发一个 IP 归属地查询接口工具

《基于Go语言开发一个IP归属地查询接口工具》在日常开发中,IP地址归属地查询是一个常见需求,本文将带大家使用Go语言快速开发一个IP归属地查询接口服务,有需要的小伙伴可以了解下... 目录功能目标技术栈项目结构核心代码（main.go）使用方法扩展功能总结在日常开发中，IP 地址归属地查询是一个常见需求：
阅读更多...
springboot集成easypoi导出word换行处理过程

springboot集成easypoi导出word换行处理过程

《springboot集成easypoi导出word换行处理过程》SpringBoot集成Easypoi导出Word时,换行符n失效显示为空格,解决方法包括生成段落或替换模板中n为回车,同时需确... 目录项目场景问题描述解决方案第一种：生成段落的方式第二种：替换模板的情况，换行符替换成回车总结项目场景s
阅读更多...
Python的Darts库实现时间序列预测

Python的Darts库实现时间序列预测

《Python的Darts库实现时间序列预测》Darts一个集统计、机器学习与深度学习模型于一体的Python时间序列预测库,本文主要介绍了Python的Darts库实现时间序列预测,感兴趣的可以了解... 目录目录一、什么是 Darts？二、安装与基本配置安装 Darts导入基础模块三、时间序列数据结构与
阅读更多...
MyBatis Plus实现时间字段自动填充的完整方案

MyBatis Plus实现时间字段自动填充的完整方案

《MyBatisPlus实现时间字段自动填充的完整方案》在日常开发中,我们经常需要记录数据的创建时间和更新时间,传统的做法是在每次插入或更新操作时手动设置这些时间字段,这种方式不仅繁琐,还容易遗漏,... 目录前言解决目标技术栈实现步骤1. 实体类注解配置2. 创建元数据处理器3. 服务层代码优化填充机制详
阅读更多...
C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...
C# LiteDB处理时间序列数据的高性能解决方案

C# LiteDB处理时间序列数据的高性能解决方案

《C#LiteDB处理时间序列数据的高性能解决方案》LiteDB作为.NET生态下的轻量级嵌入式NoSQL数据库,一直是时间序列处理的优选方案,本文将为大家大家简单介绍一下LiteDB处理时间序列数... 目录为什么选择LiteDB处理时间序列数据第一章：LiteDB时间序列数据模型设计1.1 核心设计原则
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2