时间概念呢

时间戳

  • Unix时间戳（Unix timestamp）定义为从1970年01月01日00时00分00秒(UTC)起至现在经过的总秒数
  • 不论东西南北、在地球的每一个角落都是相同

日期格式

  • 字符串

python中转换关系py_time.png

go中转换关系go_time.png

获取时间相关函数

获取当前时间

  • 代码
  1. package main
  3. import (
  4.     "log"
  5.     "strconv"
  6.     "time"
  7. )
  9. func numLen(n int64) int {
  10.     return len(strconv.Itoa(int(n)))
  11. }
  13. func main() {
  15.     now := time.Now()
  16.     log.Printf("[当前时间对象为：%v]", now)
  17.     log.Printf("[当前时间戳 秒级：%v][位数:%v]", now.Unix(), numLen(now.Unix()))
  18.     log.Printf("[当前时间戳 毫秒级：%v][位数:%v]", now.UnixNano()/1e6, numLen(now.UnixNano()/1e6))
  19.     log.Printf("[当前时间戳 纳秒级：%v][位数:%v]", now.UnixNano(), numLen(now.UnixNano()))
  20.     log.Printf("[当前时间戳 纳秒小数部分：%v]", now.Nanosecond())
  21.     /*
  22.         2021/07/17 16:34:10 [当前时间对象为：2021-07-17 16:34:10.2999431 +0800 CST m=+0.007295301]
  23.         2021/07/17 16:34:10 [当前时间戳 秒级：1626510850][位数:10]
  24.         2021/07/17 16:34:10 [当前时间戳 毫秒级：1626510850299][位数:13]
  25.         2021/07/17 16:34:10 [当前时间戳 纳秒级：1626510850299943100][位数:19]
  26.         2021/07/17 16:34:10 [当前时间戳 纳秒小数部分：299943100]
  27.     */
  28. }

结论

  • 时间戳返回 int64
  • 10位数时间戳 是秒单位
  • 13位数时间戳 是毫秒单位
  • 19位数时间戳 是纳秒单位
  • 毫秒=纳秒/1e6

毫秒时间戳作用

  • prometheus默认查询就是毫秒

具体日期相关函数

  • 代码
  1. package main
  3. import (
  4.     "log"
  5.     "time"
  6. )
  8. func main() {
  10.     now := time.Now()
  11.     //返回日期
  13.     year, month, day := now.Date()
  14.     log.Printf("[通过now.Data获取][年：%d 月:%d 日:%d]", year, month, day)
  15.     log.Printf("[直接获取年 %d]", now.Year())
  16.     log.Printf("[直接获取月 %d]", now.Month())
  17.     log.Printf("[直接获取日 %d]", now.Day())
  19.     // 分 时 秒
  21.     hour, minute, second := now.Clock()
  22.     log.Printf("[通过now.Clock获取][时：%d 分:%d 秒:%d]", hour, minute, second)
  23.     log.Printf("[直接获取时 %d]", now.Hour())
  24.     log.Printf("[直接获取分 %d]", now.Minute())
  25.     log.Printf("[直接获取秒 %d]", now.Second())
  27.     // 星期几
  28.     log.Printf("[直接获取星期几 %d]", now.Weekday())
  29.     // 时区
  30.     zone, offset := now.Zone()
  31.     log.Printf("[直接获取时区  %v ，和东utc时区差 几个小时：%d]", zone, offset/3600)
  33.     log.Printf("[今天是 %d年 中的第 %d天]", now.Year(), now.YearDay())
  34.     /*
  35.         2021/07/17 16:44:57 [通过now.Data获取][年：2021 月:7 日:17]
  36.         2021/07/17 16:44:57 [直接获取年 2021]
  37.         2021/07/17 16:44:57 [直接获取月 7]
  38.         2021/07/17 16:44:57 [直接获取日 17]
  39.         2021/07/17 16:44:57 [通过now.Clock获取][时：16 分:44 秒:57]
  40.         2021/07/17 16:44:57 [直接获取时 16]
  41.         2021/07/17 16:44:57 [直接获取分 44]
  42.         2021/07/17 16:44:57 [直接获取秒 57]
  43.         2021/07/17 16:44:57 [直接获取星期几 6]
  44.         2021/07/17 16:44:57 [直接获取时区  CST ，和东utc时区差 几个小时：8]
  45.         2021/07/17 16:44:57 [今天是 2021年 中的第 198天]
  46.     */
  47. }

格式化时间

  • Go 语言提供了时间类型格式化函数 Format()， 2006-01-02 15:04:05，也很好记忆(2006 1 2 3 4 5)

时间对象转字符串

  1. package main
  3. import (
  4.     "log"
  5.     "time"
  6. )
  8. func main() {
  9.     now := time.Now()
  10.     log.Printf("[全部 ：%v]",now.Format("2006-01-02 15:04:05"))
  11.     log.Printf("[只有年 ：%v]",now.Format("2006"))
  12.     log.Printf("[/分割 ：%v]",now.Format("2006/01/02 15:04"))
  13. }

时间戳与日期字符串相互转化

  • 要先转成将时间戳转成 time.Time 类型再格式化成日期格式。
  1. package main
  3. import (
  4.     "log"
  5.     "time"
  6. )
  8. func main() {
  9.     // 时间戳
  10.     ts := time.Now().Unix()
  11.     layout := "2006-01-02 15:04:05"
  12.     // 构造时间对象
  13.     t := time.Unix(ts, 0)
  14.     log.Printf(t.Format(layout))
  15. }

日期字符串转时间戳

  • 解析时常用 time.ParseInLocation()，可以指定时区
  1. package main
  3. import (
  4.     "log"
  5.     "time"
  6. )
  8. func main() {
  9.     tStr := "2021-07-17 16:52:59"
  10.     layout := "2006-01-02 15:04:05"
  12.     t1, _ := time.ParseInLocation(layout, tStr, time.Local)
  13.     t2, _ := time.ParseInLocation(layout, tStr, time.UTC)
  14.     log.Printf("[ %s的 CST时区的时间戳为 ：%d]", tStr, t1.Unix())
  15.     log.Printf("[ %s的 UTC时区的时间戳为 ：%d]", tStr, t2.Unix())
  16.     log.Printf("[UTC - CST =%d 小时]", (t2.Unix()-t1.Unix())/3600)
  17. }

时间差

  1. package main
  3. import (
  4.     "log"
  5.     "time"
  6. )
  8. var layout = "2006-01-02 15:04:05"
  10. func tTostr(t time.Time) string {
  11.     return time.Unix(t.Unix(), 0).Format(layout)
  12. }
  14. func main() {
  15.     now := time.Now()
  16.     log.Printf("[当前时间为：%v]", tTostr(now))
  17.     // 1小时1分1秒后
  18.     t1, _ := time.ParseDuration("1h1m1s")
  19.     m1 := now.Add(t1)
  20.     log.Printf("[ 1小时1分1秒后时间为：%v]", tTostr(m1))
  22.     // 1小时1分1秒前
  23.     t2, _ := time.ParseDuration("-1h1m1s")
  24.     m2 := now.Add(t2)
  25.     log.Printf("[ 1小时1分1秒 前时间为：%v]", tTostr(m2))
  27.     // sub计算两个时间差
  28.     sub1 := now.Sub(m2)
  29.     log.Printf("[ 时间差 ：%s 相差小时数：%v 相差分钟数：%v ]", sub1.String(), sub1.Hours(), sub1.Minutes())
  31.     t3, _ := time.ParseDuration("-3h3m3s")
  32.     m3 := now.Add(t3)
  33.     log.Printf("[time.since 当前时间与t的时间差 ：%v]", time.Since(m3))
  34.     log.Printf("[time.until t 当前时间的时间差 ：%v]", time.Until(m3))
  35.     m4 := now.AddDate(0, 0, 5)
  36.     log.Printf("[5天后 的时间 ：%v]", m4)
  37. }

日期比较

  1. package main
  3. import (
  4.     "log"
  5.     "time"
  6. )
  8. var layout = "2006-01-02 15:04:05"
  10. func tTostr(t time.Time) string {
  11.     return time.Unix(t.Unix(), 0).Format(layout)
  12. }
  14. func main() {
  15.     now := time.Now()
  16.     t1, _ := time.ParseDuration("1h")
  17.     m1 := now.Add(t1)
  18.     log.Printf("[a.after(b) a在b之后 ：%v]", m1.After(now))
  19.     log.Printf("[a.Before(b) a在b之前 ：%v]", now.Before(m1))
  20.     log.Printf("[a.Equal(b) a=b ：%v]", m1.Equal(now))
  21. }