go系列-时间处理

时间：2025-03-02 08:15:06

1 获取当前时间

currentTime:=()     //获取当前时间，类型是Go的时间类型Time
t1:=().Year()        //年
t2:=().Month()       //月
t3:=().Day()         //日
t4:=().Hour()        //小时
t5:=().Minute()      //分钟
t6:=().Second()      //秒
t7:=().Nanosecond()  //纳秒
//如果获取UTC时间，则可以使用:=(t1,t2,t3,t4,t5,t6,t7,) //获取当前时间，返回当前时间Time     
(currentTime)       //打印结果：2017-04-11 12:52:52.794351777 +0800 CST
(t1,t2,t3,t4,t5,t6)     //打印结果：2017 April 11 12 52 52
(currentTimeData)    //打印结果：2017-04-11 12:52:52.794411287 +0800 CST

 ()和Date()方法都可以获取当前时间，()用起来比较简单，但是Date()可以获取不同的精确值，如(t1,t2,t3,t4,t5,t6,0,)将毫秒省略，精确到秒，结果为：2017-04-11 12:52:52 +0800 CST。

2 获取当前时间戳   

timeUnix:=().Unix()            //单位s,打印结果:1491888244
timeUnixNano:=().UnixNano()  //单位纳秒,打印结果：1491888244752784461

3 获取当前时间的字符串格式     

timeStr:=().Format("2006-01-02 15:04:05")  //当前时间的字符串，2006-01-02 15:04:05据说是golang的诞生时间，固定写法
(timeStr)    //打印结果：2017-04-11 13:24:04

4 相互转化

4.1 时间戳转时间字符串 (int64 > string)  

timeUnix:=().Unix()   //已知的时间戳
formatTimeStr:=(timeUnix,0).Format("2006-01-02 15:04:05")
(formatTimeStr)   //打印结果：2017-04-11 13:30:39

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

formatTimeStr="2017-04-11 13:33:37"
formatTime,err:=("2006-01-02 15:04:05",formatTimeStr)
if err==nil{
    (formatTime) //打印结果：2017-04-11 13:33:37 +0000 UTC
}

4.3 时间字符串转时间戳 (string >  int64) 

formatTimeStr="2017-04-11 13:33:37"
formatTime,err:=("2006-01-02 15:04:05",formatTimeStr)
utime := ()
if err == nil{
    (utime) //打印结果：2017-04-11 13:33:37 +0000 UTC
}

5 时间计算

5.1 获取今天0点0时0分的时间戳

currentTime := () 
startTime := ((), (), (), 0, 0, 0, 0, ())
(startTime)
(("2006/01/02 15:04:05"))

5.2 获取今天23:59:59秒的时间戳

currentTime := () 
endTime := ((), (), (), 23, 59, 59, 0, ()) 
(endTime) 
(("2006/01/02 15:04:05"))

5.3 获取1分钟之前的时间

m, _ := ("-1m") 
result := (m)   
(result)
(("2006/01/02 15:04:05"))

5.4 获取1小时之前的时间

m, _ := ("-1h") 
result := (m) 
(result) 
(("2006/01/02 15:04:05"))

5.5 获取1分钟之后的时间

m, _ := ("1m") 
result := (m)   
(result) 
(("2006/01/02 15:04:05"))

5.6 获取1小时之后的时间

m, _ := ("1h") 
result := (m) 
(result) 
(("2006/01/02 15:04:05"))

5.7 计算两个时间戳之间的时间

afterTime, _ := ("1h") 
result := (afterTime)   
beforeTime, _ := ("-1h") 
result2 := (beforeTime)   
m := (result2)
("%v 分钟 \n", ())   
h := (result2) 
("%v小时 \n", ())   
d := (result2) 
("%v 天\n", ()/24)

5.8 判断一个时间是否在一个时间之后

stringTime, _ := ("2006-01-02 15:04:05", "2019-12-12 12:00:00") 
beforeOrAfter := (())   

if true == beforeOrAfter {   
("2019-12-12 12:00:00在当前时间之后!") 
   } else {  
 ("2019-12-12 12:00:00在当前时间之前!") 
}

5.9 判断一个时间相比另外一个时间过去了多久 

startTime := () 
( * 5)   
("离现在过去了：", (startTime))

6 睡眠指定时间(小时级到纳秒级)

golang的休眠可以使用time包中的Sleep函数实现,本节主要介绍关于go 睡眠指定时间(小时级到纳秒级）相关实现。

6.1 单位

单位为:1ns (纳秒)

6.2 转换单位

  • 1纳秒 =1000皮秒
  • 1纳秒 =0.001 微秒
  • 1纳秒 =0.000 001毫秒 　 
  • 1纳秒 =0.000 000 001秒

go用来指定睡眠时间的函数为，接口为： 

// 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钟，不能直接写 (5) ，而应该写(5 * )

其中就是一个Duration类型，表示1s的时间间隔，乘系数5就得到5s的时间间隔。

除了外，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秒：

(1* + 10* + 5*) 

7 耗时统计

7.1 常规写法

package main
import (
    "fmt"
    "time"
)
 
func main() {
    bT := ()            // 开始时间
    (5*)
    eT := (bT)      // 从开始到当前所消耗的时间
 
    ("Run time: ", eT)
}

运行结果：

Run time:  5.001531s

7.2 原始方式

在函数起始位置计算当前时间，在函数结束位置算出耗时。

package main
import (
    "fmt"
    "time"
)
 
func sum(n int) int {
    var total int
    startT := ()//计算当前时间    total := 0
        for i:=1; i <= n; i++ {
            total += i
        }
    tc := (startT)//计算耗时
    ("time cost = %v\n", tc)
        return total
}
func main() {
        count := sum(100)
    ("count = %v\n", count)
}

运行结果：

time cost = 250ns
count = 5050

7.3 简洁方法

计算当前时间与计算耗时放在两处，难免显得丑陋，且不易阅读。如果有多个函数需要统计耗时，那么多处书写重复的两行代码会造成代码冗余。由于 Golang 提供了函数延时执行的功能，借助 defer ，可以通过函数封装的方式来避免代码冗余。 

package main
import (
    "fmt"
    "time"
)
 
//耗时统计函数
func timeCost(start ){
    tc:=(start)
    ("time cost = %v\n", tc)
}
func sum(n int) int {
    defer timeCost(())
        total := 0
        for i:=1; i <= n; i++ {
            total += i
        }
    return total
}
func main() {
        count := sum(100)
    ("count = %v\n", count)
}

运行结果：

time cost = 333ns
count = 5050

通过输出可以看到sum()耗时增加了，因为增加了一次timeCost()函数调用。不过相比于函数封装带来的便利与代码美观，新增的耗时是微不足道可以接受的。

7.4 优雅方法

每次调用耗时统计函数timeCost()都需要传入()，重复书写()无疑造成了代码冗余。在上面的基础上，进行进一步的封装，实现如下：

package main
import (
    "fmt"
    "time"
)
//耗时统计函数
func timeCost() func() {
    start := ()
    return func() {
        tc:=(start)
        ("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)
    ("count = %v\n", count)
}

运行结果：

time cost = 1.204µs
count = 5050

相关文章