go时间戳 go中的时间处理过程 go 时间戳转字符串

目录

• 1获取当前时刻
• 2获取当前时刻戳
• 3获取当前时刻的字符串格式
• 4相互转化
• 4.1时刻戳转时刻字符串(int64 > string)
• 4.2时刻字符串转时刻(string >Time)
• 4.3时刻字符串转时刻戳(string >int64)
• 5 时刻计算
• 5.1获取今天0点0时0分的时刻戳
• 5.2获取今天23:59:59秒的时刻戳
• 5.3获取1分钟之前的时刻
• 5.4获取1小时之前的时刻
• 5.5获取1分钟之后的时刻
• 5.6获取1小时之后的时刻
• 5.7 计算两个时刻戳之间的时刻
• 5.8判断一个时刻是否在一个时刻之后
• 5.9判断一个时刻相比另外一个时刻过去了多久
• 6time.Sleep睡眠指定时刻(小时级到纳秒级)
• 6.1 单位
• 6.2转换单位
• 7耗时统计
• 7.1 常规写法
• 7.2 原始方式
• 7.3简洁技巧
• 7.4优雅技巧
• 拓展资料

1获取当前时刻

currentTime:=time.Now() //获取当前时刻，类型是Go的时刻类型Timet1:=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 CSTfmt.Println(t1,t2,t3,t4,t5,t6) //打印结局：2017 April 11 12 52 52fmt.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-1112:52:52+0800CST。

2获取当前时刻戳

timeUnix:=time.Now().Unix() //单位s,打印结局:1491888244timeUnixNano:=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 >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))

6time.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(1time.Hour + 10time.Minute + 5time.Second)

7耗时统计

7.1 常规写法

package mainimport ( “fmt” “time”) func main() bT := time.Now() // 开始时刻 time.Sleep(5time.Second) eT := time.Since(bT) // 从开始到当前所消耗的时刻 fmt.Println(“Run time: “, eT)}

运行结局：

Run time: 5.001531s

7.2 原始方式

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

package mainimport ( “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 = %vn”, tc) return total}func main() count := sum(100) fmt.Printf(“count = %vn”, count)}

运行结局：

time cost = 250nscount = 5050

7.3简洁技巧

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

package mainimport ( “fmt” “time”) //耗时统计函数func timeCost(start time.Time) tc:=time.Since(start) fmt.Printf(“time cost = %vn”, 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 = %vn”, count)}

运行结局：

time cost = 333nscount = 5050

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

7.4优雅技巧

每次调用耗时统计函数timeCost()都需要传入time.Now()，重复书写time.Now()无疑造成了代码冗余。

在上面的基础上，进行进一步的封装，实现如下：

package mainimport ( “fmt” “time”)//耗时统计函数func timeCost() func() start := time.Now() return func() tc:=time.Since(start) fmt.Printf(“time cost = %vn”, 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 = %vn”, count)}

运行结局：

time cost = 1.204μscount = 5050

拓展资料

以上为个人经验，希望能给大家一个参考，也希望大家多多支持风君子博客。

无论兄弟们可能感兴趣的文章:

• 15个Golang中时刻处理的实用函数
• Golang时刻处理库go-carbon?v2.2.13发布细则
• Go语言时刻处理必备技巧全解析
• Golang时刻处理中容易踩的坑分析解决
• 详解Golang时刻处理的踩坑及解决
• 详解Go?中的时刻处理